Je dobre známou skutočnosťou, že zlučovacie triedenie prebieha rýchlejšie ako vkladanie. Používanie asymptotická analýza . môžeme dokázať, že zlučovacie triedenie prebieha v čase O(nlogn) a triedenie vkladania trvá O(n^2). Je zrejmé, že zlučovacie triedenie používa prístup rozdeľuj a panuj rekurzívnym riešením problémov, kde pri triedení vkladania nasleduje inkrementálny prístup. Ak ešte podrobnejšie preskúmame analýzu časovej zložitosti, zistíme, že triedenie vkladania nie je také zlé. Prekvapivo vkladanie triediť beaty zlučovať triedenie na menšej vstupnej veľkosti. Je to preto, že existuje málo konštánt, ktoré pri odvodzovaní časovej zložitosti ignorujeme. Pri väčších veľkostiach vstupu rádu 10^4 to neovplyvňuje správanie našej funkcie. Ale keď vstupné veľkosti klesnú pod povedzme menej ako 40, potom konštanty v rovnici dominujú vstupnej veľkosti „n“. Zatiaľ je všetko v poriadku. Ale s takouto matematickou analýzou som nebol spokojný. Ako vysokoškolák informatiky musíme veriť v písanie kódu. Napísal som program C, aby som získal pocit, ako algoritmy navzájom súťažia o rôzne veľkosti vstupov. A tiež, prečo sa robí taká prísna matematická analýza na stanovenie časovej zložitosti týchto triediacich algoritmov.
pridať reťazec
Implementácia:
CPP#include
import java.util.Scanner; import java.util.Arrays; import java.util.Random; public class SortingAlgorithms { // Maximum element in array static final int MAX_ELEMENT_IN_ARRAY = 1000000001; public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int t = scanner.nextInt(); for (int i = 0; i < t; i++) { int size = scanner.nextInt(); int num_of_times = scanner.nextInt(); testSortingRuntimes(size num_of_times); } scanner.close(); } static int[] generateRandomArray(int n) { // Generate an array of n random integers. int[] arr = new int[n]; Random random = new Random(); for (int i = 0; i < n; i++) { arr[i] = random.nextInt(MAX_ELEMENT_IN_ARRAY); } return arr; } static void insertionSortAsc(int[] a int start int end) { // Perform an in-place insertion sort on a from start to end. for (int i = start + 1; i <= end; i++) { int key = a[i]; int j = i - 1; while (j >= start && a[j] > key) { a[j + 1] = a[j]; j--; } a[j + 1] = key; } } static void merge(int[] a int start int end int mid) { // Merge two sorted sublists of a. // The first sublist is a[start:mid+1] and the second sublist is a[mid+1:end+1]. int[] aux = new int[end - start + 1]; int i = start j = mid + 1 k = 0; while (i <= mid && j <= end) { if (a[i] <= a[j]) { aux[k++] = a[i++]; } else { aux[k++] = a[j++]; } } while (i <= mid) { aux[k++] = a[i++]; } while (j <= end) { aux[k++] = a[j++]; } System.arraycopy(aux 0 a start aux.length); } static void mergeSort(int[] a) { // Perform an in-place merge sort on a. mergeSortHelper(a 0 a.length - 1); } static void mergeSortHelper(int[] a int start int end) { // Recursive merge sort function. if (start < end) { int mid = start + (end - start) / 2; mergeSortHelper(a start mid); mergeSortHelper(a mid + 1 end); merge(a start end mid); } } static void insertionAndMergeSortCombine(int[] a int start int end int k) { /* Perform an in-place sort on a from start to end. If the size of the list is less than or equal to k use insertion sort. Otherwise use merge sort. */ if (start < end) { int size = end - start + 1; if (size <= k) { insertionSortAsc(a start end); } else { int mid = start + (end - start) / 2; insertionAndMergeSortCombine(a start mid k); insertionAndMergeSortCombine(a mid + 1 end k); merge(a start end mid); } } } static void testSortingRuntimes(int size int num_of_times) { // Test the runtime of the sorting algorithms. double insertionSortTime = 0; double mergeSortTime = 0; double mergeSortAndInsertionSortMixTime = 0; double qsortTime = 0; for (int i = 0; i < num_of_times; i++) { int[] a = generateRandomArray(size); int[] b = Arrays.copyOf(a a.length); long start = System.currentTimeMillis(); insertionSortAsc(b 0 b.length - 1); long end = System.currentTimeMillis(); insertionSortTime += end - start; int[] c = Arrays.copyOf(a a.length); start = System.currentTimeMillis(); mergeSort(c); end = System.currentTimeMillis(); mergeSortTime += end - start; int[] d = Arrays.copyOf(a a.length); start = System.currentTimeMillis(); insertionAndMergeSortCombine(d 0 d.length - 1 40); end = System.currentTimeMillis(); mergeSortAndInsertionSortMixTime += end - start; int[] e = Arrays.copyOf(a a.length); start = System.currentTimeMillis(); Arrays.sort(e); end = System.currentTimeMillis(); qsortTime += end - start; } insertionSortTime /= num_of_times; mergeSortTime /= num_of_times; mergeSortAndInsertionSortMixTime /= num_of_times; qsortTime /= num_of_times; System.out.println('nTime taken to sort:n' + '(i) Insertion sort: ' + insertionSortTime + 'n' + '(ii) Merge sort: ' + mergeSortTime + 'n' + '(iii) Insertion-mergesort-hybrid: ' + mergeSortAndInsertionSortMixTime + 'n' + '(iv) Qsort library function: ' + qsortTime + 'n'); } }
import time import random import copy from typing import List # Maximum element in array MAX_ELEMENT_IN_ARRAY = 1000000001 def generate_random_array(n: int) -> List[int]: #Generate a list of n random integers. return [random.randint(0 MAX_ELEMENT_IN_ARRAY) for _ in range(n)] def insertion_sort_asc(a: List[int] start: int end: int) -> None: #Perform an in-place insertion sort on a from start to end. for i in range(start + 1 end + 1): key = a[i] j = i - 1 while j >= start and a[j] > key: a[j + 1] = a[j] j -= 1 a[j + 1] = key def merge(a: List[int] start: int end: int mid: int) -> None: #Merge two sorted sublists of a. #The first sublist is a[start:mid+1] and the second sublist is a[mid+1:end+1]. aux = [] i = start j = mid + 1 while i <= mid and j <= end: if a[i] <= a[j]: aux.append(a[i]) i += 1 else: aux.append(a[j]) j += 1 while i <= mid: aux.append(a[i]) i += 1 while j <= end: aux.append(a[j]) j += 1 a[start:end+1] = aux def _merge_sort(a: List[int] start: int end: int) -> None: #Recursive merge sort function. if start < end: mid = start + (end - start) // 2 _merge_sort(a start mid) _merge_sort(a mid + 1 end) merge(a start end mid) def merge_sort(a: List[int]) -> None: #Perform an in-place merge sort on a. _merge_sort(a 0 len(a) - 1) def insertion_and_merge_sort_combine(a: List[int] start: int end: int k: int) -> None: ''' Perform an in-place sort on a from start to end. If the size of the list is less than or equal to k use insertion sort. Otherwise use merge sort. ''' if start < end: size = end - start + 1 if size <= k: insertion_sort_asc(a start end) else: mid = start + (end - start) // 2 insertion_and_merge_sort_combine(a start mid k) insertion_and_merge_sort_combine(a mid + 1 end k) merge(a start end mid) def test_sorting_runtimes(size: int num_of_times: int) -> None: #Test the runtime of the sorting algorithms. insertion_sort_time = 0 merge_sort_time = 0 merge_sort_and_insertion_sort_mix_time = 0 qsort_time = 0 for _ in range(num_of_times): a = generate_random_array(size) b = copy.deepcopy(a) start = time.time() insertion_sort_asc(b 0 len(b) - 1) end = time.time() insertion_sort_time += end - start c = copy.deepcopy(a) start = time.time() merge_sort(c) end = time.time() merge_sort_time += end - start d = copy.deepcopy(a) start = time.time() insertion_and_merge_sort_combine(d 0 len(d) - 1 40) end = time.time() merge_sort_and_insertion_sort_mix_time += end - start start = time.time() a.sort() end = time.time() qsort_time += end - start insertion_sort_time /= num_of_times merge_sort_time /= num_of_times merge_sort_and_insertion_sort_mix_time /= num_of_times qsort_time /= num_of_times print(f'nTime taken to sort:n' f'(i)Insertion sort: {insertion_sort_time}n' f'(ii)Merge sort: {merge_sort_time}n' f'(iii)Insertion-mergesort-hybrid: {merge_sort_and_insertion_sort_mix_time}n' f'(iv)Qsort library function: {qsort_time}n') def main() -> None: t = int(input()) for _ in range(t): size num_of_times = map(int input().split()) test_sorting_runtimes(size num_of_times) if __name__ == '__main__': main()
// Importing required modules const { performance } = require('perf_hooks'); // Maximum element in array const MAX_ELEMENT_IN_ARRAY = 1000000001; // Function to generate a list of n random integers function generateRandomArray(n) { return Array.from({length: n} () => Math.floor(Math.random() * MAX_ELEMENT_IN_ARRAY)); } // Function to perform an in-place insertion sort on a from start to end function insertionSortAsc(a start end) { for (let i = start + 1; i <= end; i++) { let key = a[i]; let j = i - 1; while (j >= start && a[j] > key) { a[j + 1] = a[j]; j -= 1; } a[j + 1] = key; } } // Function to merge two sorted sublists of a function merge(a start end mid) { let aux = []; let i = start; let j = mid + 1; while (i <= mid && j <= end) { if (a[i] <= a[j]) { aux.push(a[i]); i += 1; } else { aux.push(a[j]); j += 1; } } while (i <= mid) { aux.push(a[i]); i += 1; } while (j <= end) { aux.push(a[j]); j += 1; } for (let i = start; i <= end; i++) { a[i] = aux[i - start]; } } // Recursive merge sort function function _mergeSort(a start end) { if (start < end) { let mid = start + Math.floor((end - start) / 2); _mergeSort(a start mid); _mergeSort(a mid + 1 end); merge(a start end mid); } } // Function to perform an in-place merge sort on a function mergeSort(a) { _mergeSort(a 0 a.length - 1); } // Function to perform an in-place sort on a from start to end function insertionAndMergeSortCombine(a start end k) { if (start < end) { let size = end - start + 1; if (size <= k) { insertionSortAsc(a start end); } else { let mid = start + Math.floor((end - start) / 2); insertionAndMergeSortCombine(a start mid k); insertionAndMergeSortCombine(a mid + 1 end k); merge(a start end mid); } } } // Function to test the runtime of the sorting algorithms function testSortingRuntimes(size numOfTimes) { let insertionSortTime = 0; let mergeSortTime = 0; let mergeSortAndInsertionSortMixTime = 0; let qsortTime = 0; for (let _ = 0; _ < numOfTimes; _++) { let a = generateRandomArray(size); let b = [...a]; let start = performance.now(); insertionSortAsc(b 0 b.length - 1); let end = performance.now(); insertionSortTime += end - start; let c = [...a]; start = performance.now(); mergeSort(c); end = performance.now(); mergeSortTime += end - start; let d = [...a]; start = performance.now(); insertionAndMergeSortCombine(d 0 d.length - 1 40); end = performance.now(); mergeSortAndInsertionSortMixTime += end - start; start = performance.now(); a.sort((a b) => a - b); end = performance.now(); qsortTime += end - start; } insertionSortTime /= numOfTimes; mergeSortTime /= numOfTimes; mergeSortAndInsertionSortMixTime /= numOfTimes; qsortTime /= numOfTimes; console.log(`nTime taken to sort:n(i)Insertion sort: ${insertionSortTime}n(ii)Merge sort: ${mergeSortTime}n(iii)Insertion-mergesort-hybrid: ${mergeSortAndInsertionSortMixTime}n(iv)Qsort library function: ${qsortTime}n`); } // Main function function main() { let t = parseInt(prompt('Enter the number of test cases: ')); for (let _ = 0; _ < t; _++) { let size = parseInt(prompt('Enter the size of the array: ')); let numOfTimes = parseInt(prompt('Enter the number of times to run the test: ')); testSortingRuntimes(size numOfTimes); } } // Call the main function main();
Porovnal som doby chodu nasledujúcich algoritmov:
dhanashree verma
- Zoradenie vloženia : Tradičný algoritmus bez úprav/optimalizácie. Funguje veľmi dobre pre menšie vstupné veľkosti. A áno, porazí zlúčenie
- Ide osud : Dodržiava prístup rozdeľuj a panuj. Pre vstupné veľkosti rádu 10^5 je tento algoritmus správnou voľbou. Spôsobuje to nepraktické zoradenie vkladania pre také veľké vstupné veľkosti.
- Kombinovaná verzia zoradenia vloženia a zoradenia zlúčením: Trochu som vylepšil logiku zlučovania, aby som dosiahol podstatne lepší čas chodu pre menšie vstupné veľkosti. Ako vieme, zlučovacie triedenie rozdeľuje svoj vstup na dve polovice, kým nie je dostatočne triviálne na triedenie prvkov. Ale tu, keď vstupná veľkosť klesne pod prah, ako je „n“< 40 then this hybrid algorithm makes a call to traditional insertion sort procedure. From the fact that insertion sort runs faster on smaller inputs and merge sort runs faster on larger inputs this algorithm makes best use both the worlds.
- Rýchle triedenie: Tento postup som nerealizoval. Toto je funkcia knižnice qsort(), ktorá je dostupná v . Tento algoritmus som zvažoval, aby som poznal význam implementácie. Na minimalizáciu počtu krokov a maximálne využitie základných jazykových primitív na implementáciu algoritmu tým najlepším možným spôsobom si vyžaduje veľkú odbornosť v oblasti programovania. To je hlavný dôvod, prečo sa odporúča používať funkcie knižnice. Sú napísané tak, aby zvládli čokoľvek a všetko. Optimalizujú v maximálnej možnej miere. A predtým, než na svoju analýzu zabudnem, qsort() beží neuveriteľne rýchlo na prakticky akejkoľvek veľkosti vstupu!
Analýza:
- Vstup: Užívateľ musí zadať, koľkokrát chce testovať algoritmus zodpovedajúci počtu testovacích prípadov. Pre každý testovací prípad musí používateľ zadať dve celé čísla oddelené medzerou, ktoré označujú vstupnú veľkosť „n“ a „num_of_times“ označujúce, koľkokrát chce spustiť analýzu a urobiť priemer. (Vysvetlenie: Ak je „počet_časov“ 10, každý z vyššie uvedených algoritmov sa spustí 10-krát a vezme sa priemer. Toto sa robí preto, že vstupné pole sa generuje náhodne podľa zadanej vstupnej veľkosti. Všetky vstupné polia môžu byť zoradené. Mohlo by to zodpovedať najhoršiemu prípadu t. j. zostupnému poradiu. Aby sa predišlo časom spustenia a spusteniu takejto vstupnej_matice. berie sa priemer.) rutina clock() a makro CLOCKS_PER_SEC from sa používa na meranie času. Kompilácia: Vyššie uvedený kód som napísal v prostredí Linuxu (Ubuntu 16.04 LTS). Skopírujte útržok kódu vyššie. Zostavte ho pomocou kľúča gcc vo vstupoch podľa špecifikácie a obdivujte silu triediacich algoritmov!
- Výsledky: Ako môžete vidieť pri malých vstupných veľkostiach vloženie triedenie beaty zlúčenie triedenie podľa 2 * 10^-6 sekúnd. Tento časový rozdiel ale nie je až taký výrazný. Na druhej strane hybridný algoritmus a funkcia knižnice qsort() fungujú rovnako dobre ako triedenie vkladania.
Vstupná veľkosť sa teraz zväčší približne 100-krát na n = 1000 z n = 30. Rozdiel je teraz hmatateľný. Zoradenie zlúčením prebieha 10-krát rýchlejšie ako zoradenie vložením. Medzi výkonom hybridného algoritmu a rutiny qsort() je opäť súvislosť. To naznačuje, že qsort () je implementovaný spôsobom, ktorý je viac-menej podobný nášmu hybridnému algoritmu, t. j. prepínanie medzi rôznymi algoritmami, aby sa z nich dalo čo najlepšie.
Nakoniec sa vstupná veľkosť zvýši na 10^5 (1 Lakh!), čo je s najväčšou pravdepodobnosťou ideálna veľkosť používaná v praktických scenároch. V porovnaní s predchádzajúcim vstupom n = 1000, kde zlúčiť triediť beat vkladanie triediť 10-krát rýchlejšie, je tu rozdiel ešte výraznejší. Zlúčiť triedenie bije vkladanie triedenie podľa 100-krát! Hybridný algoritmus, ktorý sme napísali, v skutočnosti vykonáva tradičné zlučovacie triedenie tým, že beží o 0,01 sekundy rýchlejšie. A nakoniec, knižničná funkcia qsort() nám konečne dokazuje, že implementácia tiež hrá kľúčovú úlohu pri dôslednom meraní prevádzkových časov, pretože beží o 3 milisekundy rýchlejšie! :D
Poznámka: Nespúšťajte vyššie uvedený program s n >= 10^6, pretože to bude vyžadovať veľa výpočtového výkonu. Ďakujem a prajem príjemné kódovanie! :)
Vytvoriť kvíz