És un fet ben establert que l'ordenació per fusió s'executa més ràpid que l'ordenació per inserció. Utilitzant anàlisi asimptòtica . podem demostrar que l'ordenació per fusió s'executa en temps O(nlogn) i que l'ordenació per inserció pren O(n^2). És obvi perquè l'ordenació per fusió utilitza un enfocament de divideix i venç mitjançant la resolució recursiva dels problemes quan l'ordenació d'inserció segueix un enfocament incremental. Si analitzem encara més l'anàlisi de la complexitat del temps, sabrem que l'ordenació d'inserció no és prou dolenta. Sorprenentment, l'ordenació per inserció supera l'ordenació de combinació en una mida d'entrada més petita. Això es deu al fet que hi ha poques constants que ignorem mentre deduïm la complexitat del temps. En mides d'entrada més grans de l'ordre 10^4, això no influeix en el comportament de la nostra funció. Però quan les mides d'entrada cauen per sota de menys de 40, llavors les constants de l'equació dominen la mida d'entrada "n". Fins aquí tot bé. Però no estava satisfet amb aquesta anàlisi matemàtica. Com a grau d'informàtica hem de creure en l'escriptura de codi. He escrit un programa en C per tenir una idea de com competeixen els algorismes entre ells per a diferents mides d'entrada. I també per què es fa una anàlisi matemàtica tan rigorosa per establir les complexitats del temps d'execució d'aquests algorismes d'ordenació.
jsp javatpoint
Implementació:
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();
He comparat els temps d'execució dels algorismes següents:
ankita dave
- Classificació per inserció : L'algoritme tradicional sense modificacions/optimitzacions. Funciona molt bé per a mides d'entrada més petites. I sí, supera l'ordenació de fusió
- Va el destí : Segueix l'enfocament del dividir i vencer. Per a mides d'entrada de l'ordre 10^5, aquest algorisme és l'opció correcta. Fa que l'ordenació d'inserció sigui poc pràctica per a mides d'entrada tan grans.
- Versió combinada d'ordenació per inserció i ordenació de combinació: He ajustat una mica la lògica de l'ordenació de combinació per aconseguir un temps d'execució considerablement millor per a mides d'entrada més petites. Com sabem, merge sort divideix la seva entrada en dues meitats fins que és prou trivial per ordenar els elements. Però aquí quan la mida d'entrada cau per sota d'un llindar com ara '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.
- Classificació ràpida: No he implementat aquest procediment. Aquesta és la funció de biblioteca qsort() que està disponible a . He considerat aquest algorisme per conèixer la importància de la implementació. Requereix una gran experiència en programació per minimitzar el nombre de passos i fer un ús màxim de les primitives del llenguatge subjacent per implementar un algorisme de la millor manera possible. Aquesta és la raó principal per la qual es recomana utilitzar funcions de biblioteca. Estan escrits per gestionar qualsevol cosa i tot. S'optimitzen al màxim possible. I abans d'oblidar-me de la meva anàlisi, qsort() s'executa molt ràpid en pràcticament qualsevol mida d'entrada!
L'anàlisi:
- Entrada: L'usuari ha de proporcionar el nombre de vegades que vol provar l'algorisme corresponent al nombre de casos de prova. Per a cada cas de prova, l'usuari ha d'introduir dos nombres enters separats per espais que denoten la mida d'entrada 'n' i el 'num_of_times' que denota el nombre de vegades que vol executar l'anàlisi i fer la mitjana. (Aclaració: si 'num_of_times' és 10, llavors cadascun dels algorismes especificats anteriorment s'executa 10 vegades i es pren la mitjana. Això es fa perquè la matriu d'entrada es genera aleatòriament corresponent a la mida d'entrada que especifiqueu. La matriu d'entrada podria estar ordenada tota. El nostre podria correspondre al pitjor dels casos, és a dir, l'ordre d'execució de l'algorisme d'entrada és decreixent. 'num_of_times' i es pren la mitjana.) La rutina clock() i la macro CLOCKS_PER_SEC from s'utilitzen per mesurar el temps trigat. Recopilació: he escrit el codi anterior a l'entorn Linux (Ubuntu 16.04 LTS). Copieu el fragment de codi anterior. Compileu-lo amb la clau gcc a les entrades tal com s'especifica i admireu el poder dels algorismes d'ordenació!
- Resultats: Com podeu veure, per a mides d'entrada petites, ordenació d'inserció, ordenació de ritmes de combinació per 2 * 10^-6 segons. Però aquesta diferència de temps no és tan significativa. D'altra banda, l'algorisme híbrid i la funció de biblioteca qsort() funcionen tan bé com l'ordenació d'inserció.
La mida d'entrada ara s'incrementa aproximadament 100 vegades fins a n = 1000 des de n = 30. La diferència ara és tangible. L'ordenació combinada s'executa 10 vegades més ràpid que l'ordenació per inserció. Hi ha de nou un lligam entre el rendiment de l'algorisme híbrid i la rutina qsort(). Això suggereix que qsort() s'implementa d'una manera més o menys semblant al nostre algorisme híbrid, és a dir, canviant entre diferents algorismes per treure'n el màxim profit.
Finalment, la mida d'entrada s'augmenta a 10^5 (1 Lakh!), que és probablement la mida ideal utilitzada en escenaris pràctics. En comparació amb l'entrada anterior n = 1000, on l'ordenació combinada supera la classificació per inserció executant-se 10 vegades més ràpid aquí, la diferència és encara més significativa. L'ordenació combinada supera l'ordenació d'inserció 100 vegades! L'algorisme híbrid que hem escrit, de fet, no realitza l'ordenació de fusió tradicional executant 0,01 segons més ràpid. I, finalment, qsort() la funció de biblioteca finalment ens demostra que la implementació també juga un paper crucial mentre mesura els temps d'execució meticulosament fent córrer 3 mil·lisegons més ràpid! :D
Nota: no executeu el programa anterior amb n >= 10^6, ja que necessitarà molta potència de càlcul. Gràcies i feliç codificació! :)
Crea un qüestionari