Dobro ugotovljeno dejstvo je, da razvrščanje z združevanjem deluje hitreje kot razvrščanje z vstavljanjem. Uporaba asimptotična analiza . lahko dokažemo, da razvrščanje z združevanjem poteka v času O(nlogn), razvrščanje z vstavljanjem pa O(n^2). To je očitno, ker razvrščanje z združevanjem uporablja pristop deli in vladaj z rekurzivnim reševanjem problemov, pri čemer razvrščanje z vstavljanjem sledi inkrementalnemu pristopu. Če še bolj natančno preučimo analizo časovne kompleksnosti, bomo ugotovili, da sortiranje vstavljanja ni tako slabo. Presenetljivo je razvrščanje z vstavljanjem boljše od razvrščanja z zlivanjem pri manjši velikosti vnosa. To je zato, ker obstaja nekaj konstant, ki jih prezremo pri sklepanju o časovni kompleksnosti. Pri večjih vhodnih velikostih reda 10^4 to ne vpliva na obnašanje naše funkcije. Toda ko vhodne velikosti padejo pod, recimo, manj kot 40, potem konstante v enačbi prevladujejo nad vhodno velikostjo 'n'. Zaenkrat gre dobro. Ampak s takšno matematično analizo nisem bil zadovoljen. Kot dodiplomski študent računalništva moramo verjeti v pisanje kode. Napisal sem program C, da dobim občutek, kako algoritmi tekmujejo med seboj za različne velikosti vnosa. In tudi, zakaj se izvaja tako stroga matematična analiza za ugotavljanje zapletenosti časa izvajanja teh algoritmov za razvrščanje.
css poravnava slik
Izvedba:
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();
Primerjal sem čas delovanja naslednjih algoritmov:
vso srečo
- Razvrstitev vstavljanja : Tradicionalni algoritem brez sprememb/optimizacije. Zelo dobro deluje pri manjših velikostih vnosa. In ja, premaga razvrščanje z združevanjem
- Gre usoda : Sledi pristopu deli in vladaj. Za vhodne velikosti reda 10^5 je ta algoritem prava izbira. Zaradi tega je razvrščanje vstavljanja nepraktično za tako velike vhodne velikosti.
- Kombinirana različica razvrščanja z vstavljanjem in združevanja: Nekoliko sem prilagodil logiko razvrščanja z združevanjem, da bi dosegel precej boljši čas delovanja za manjše velikosti vnosa. Kot vemo, sortiranje z združitvijo razdeli svoj vnos na dve polovici, dokler ni dovolj trivialen za razvrščanje elementov. Toda tukaj, ko velikost vnosa pade pod prag, kot 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.
- Hitro razvrščanje: Tega postopka nisem izvajal. To je knjižnična funkcija qsort(), ki je na voljo v . Ta algoritem sem upošteval, da bi spoznal pomen implementacije. Zahteva veliko programskega strokovnega znanja, da čim bolj zmanjšamo število korakov in čim bolj uporabimo temeljne jezikovne primitive za implementacijo algoritma na najboljši možen način. To je glavni razlog, zakaj je priporočljiva uporaba funkcij knjižnice. Napisani so za obvladovanje vsega in vsega. Optimizirajo v največji možni meri. In preden pozabim iz moje analize, qsort() deluje neverjetno hitro pri skoraj vseh velikostih vnosa!
Analiza:
- Vnos: Uporabnik mora navesti, kolikokrat želi preizkusiti algoritem, ki ustreza številu testnih primerov. Za vsak preskusni primer mora uporabnik vnesti dve celi števili, ločeni s presledki, ki označujeta velikost vnosa 'n' in 'num_of_times', ki označujeta, kolikokrat želi zagnati analizo in vzeti povprečje. (Pojasnilo: če je 'num_of_times' 10, potem se vsak od zgoraj navedenih algoritmov izvede 10-krat in vzame se povprečje. To je narejeno zato, ker je vhodna matrika ustvarjena naključno v skladu z velikostjo vnosa, ki ga določite. Vhodna matrika je lahko vsa razvrščena. Naš lahko ustreza najslabšemu primeru, tj. padajočemu vrstnemu redu. Da bi se izognili časom izvajanja takih vhodnih matrik. algoritem se izvede 'num_of_times' in vzame se povprečje.) rutina clock() in makro CLOCKS_PER_SEC iz se uporablja za merjenje porabljenega časa. Kompilacija: Zgornjo kodo sem napisal v okolju Linux (Ubuntu 16.04 LTS). Kopirajte zgornji delček kode. Prevedite ga z uporabo ključa gcc v vhodih, kot je navedeno, in občudujte moč algoritmov za razvrščanje!
- Rezultati: Kot lahko vidite, pri majhnih velikostih vnosa razvrščanje z vstavljanjem premaga razvrščanje z združevanjem z 2 * 10^-6 s. Toda ta razlika v času ni tako pomembna. Po drugi strani pa hibridni algoritem in knjižnična funkcija qsort() delujeta tako dobro kot razvrščanje z vstavljanjem.
Velikost vnosa je zdaj povečana za približno 100-krat na n = 1000 z n = 30. Razlika je zdaj otipljiva. Razvrščanje s spajanjem deluje 10-krat hitreje kot razvrščanje z vstavljanjem. Ponovno obstaja povezava med delovanjem hibridnega algoritma in rutino qsort(). To nakazuje, da je qsort() implementiran na način, ki je bolj ali manj podoben našemu hibridnemu algoritmu, tj. preklapljanje med različnimi algoritmi, da bi jih kar najbolje izkoristili.
Končno se velikost vnosa poveča na 10^5 (1 Lakh!), kar je najverjetneje idealna velikost, uporabljena v praktičnih scenarijih. V primerjavi s prejšnjim vnosom n = 1000, kjer je razvrščanje z združevanjem premagalo razvrščanje z vstavljanjem z 10-krat hitrejšim delovanjem, je tukaj razlika še pomembnejša. Razvrščanje z združitvijo je 100-krat boljše od razvrščanja z vstavljanjem! Hibridni algoritem, ki smo ga napisali, dejansko ne izvaja tradicionalnega razvrščanja z združevanjem, saj teče 0,01 sekunde hitreje. In nazadnje, knjižnična funkcija qsort() nam končno dokazuje, da igra tudi implementacija ključno vlogo pri natančnem merjenju delovnih časov, tako da teče 3 milisekunde hitreje! :D
Opomba: ne zaženite zgornjega programa z n >= 10^6, ker bo zahteval veliko računalniške moči. Hvala in srečno kodiranje! :)
Ustvari kviz