Este un fapt bine stabilit că sortarea prin îmbinare rulează mai rapid decât sortarea prin inserție. Folosind analiza asimptotică . putem demonstra că sortarea de îmbinare rulează în timp O(nlogn) și sortarea prin inserție ia O(n^2). Este evident deoarece sortarea prin îmbinare folosește o abordare împărțire și cuceri prin rezolvarea recursiv a problemelor în care sortarea prin inserție urmează o abordare incrementală. Dacă analizăm și mai mult analiza complexității timpului, vom ajunge să știm că sortarea de inserare nu este suficient de proastă. În mod surprinzător, sortarea prin inserare bate sortarea îmbinării pe dimensiunea de intrare mai mică. Acest lucru se datorează faptului că există puține constante pe care le ignorăm în timp ce deducem complexitatea timpului. La dimensiuni mai mari de intrare de ordinul 10^4, acest lucru nu influențează comportamentul funcției noastre. Dar când dimensiunile de intrare sunt sub 40, atunci constantele din ecuație domină dimensiunea de intrare „n”. Până acum, bine. Dar nu am fost mulțumit de o astfel de analiză matematică. Ca studenți în informatică, trebuie să credem în scrierea codului. Am scris un program C pentru a avea o idee despre modul în care algoritmii concurează unul împotriva celuilalt pentru diferite dimensiuni de intrare. Și, de asemenea, de ce se face o astfel de analiză matematică riguroasă pentru stabilirea complexității timpului de rulare a acestor algoritmi de sortare.
scan.nextstring java
Implementare:
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();
Am comparat timpii de rulare ai următorilor algoritmi:
Freddie Mercury născut
- Sortare prin inserare : Algoritmul tradițional fără modificări/optimizări. Funcționează foarte bine pentru dimensiuni de intrare mai mici. Și da, bate sortarea de îmbinare
- Merge sort : Urmează abordarea împărțiți și cuceriți. Pentru dimensiunile de intrare de ordinul 10^5, acest algoritm este alegerea corectă. Face sortarea de inserare nepractică pentru dimensiuni de intrare atât de mari.
- Versiunea combinată a sortării prin inserare și a sortării prin îmbinare: Am modificat puțin logica sortării de îmbinare pentru a obține un timp de rulare considerabil mai bun pentru dimensiuni de intrare mai mici. După cum știm, sortarea îmbină își împarte intrarea în două jumătăți până când este suficient de banală pentru a sorta elementele. Dar aici când dimensiunea intrării scade sub un prag, cum ar fi „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.
- Sortare rapidă: Nu am implementat această procedură. Aceasta este funcția de bibliotecă qsort() care este disponibilă în . Am luat în considerare acest algoritm pentru a cunoaște semnificația implementării. Este nevoie de o mare experiență de programare pentru a minimiza numărul de pași și pentru a utiliza cel mai mult primitivele limbajului de bază pentru a implementa un algoritm în cel mai bun mod posibil. Acesta este motivul principal pentru care se recomandă utilizarea funcțiilor bibliotecii. Sunt scrise pentru a se ocupa de orice. Ele optimizează cât mai mult posibil. Și înainte de a uita din analiza mea, qsort() rulează extraordinar de rapid pe aproape orice dimensiune de intrare!
Analiza:
- Intrare: Utilizatorul trebuie să furnizeze de câte ori dorește să testeze algoritmul corespunzător numărului de cazuri de testare. Pentru fiecare caz de testare, utilizatorul trebuie să introducă două numere întregi separate prin spațiu, care denotă dimensiunea de intrare „n” și „num_of_times” care indică numărul de ori când dorește să ruleze analiza și să ia media. (Clarificare: Dacă „num_of_times” este 10, atunci fiecare algoritm specificat mai sus rulează de 10 ori și se ia media. Acest lucru se face deoarece matricea de intrare este generată în mod aleatoriu corespunzător mărimii de intrare pe care o specificați. Matricea de intrare ar putea fi sortată în totalitate. Ar putea corespunde celui mai rău caz, adică în ordinea descrescătoare a timpilor de rulare a algoritmului de intrare pentru a evita ordinea de rulare a matricei de intrare. „num_of_times” și se ia media.) rutina clock() și macrocomanda CLOCKS_PER_SEC from este folosită pentru a măsura timpul luat. Compilare: Am scris codul de mai sus în mediul Linux (Ubuntu 16.04 LTS). Copiați fragmentul de cod de mai sus. Compilați-l folosind cheia gcc în intrările specificate și admirați puterea algoritmilor de sortare!
- Rezultate: După cum puteți vedea, pentru dimensiunile de intrare mici, sortarea inserției ritmurile merge sortarea cu 2 * 10^-6 sec. Dar această diferență de timp nu este atât de semnificativă. Pe de altă parte, algoritmul hibrid și funcția de bibliotecă qsort() funcționează ambele la fel de bune ca sortarea prin inserție.
Mărimea intrării este acum mărită de aproximativ 100 de ori la n = 1000 de la n = 30. Diferența este acum tangibilă. Sortarea prin îmbinare rulează de 10 ori mai rapid decât sortarea prin inserare. Există din nou o legătură între performanța algoritmului hibrid și rutina qsort(). Acest lucru sugerează că qsort() este implementat într-un mod care este mai mult sau mai puțin similar cu algoritmul nostru hibrid, adică comutarea între diferiți algoritmi pentru a profita la maximum de ei.
În cele din urmă, dimensiunea de intrare este mărită la 10^5 (1 Lakh!), care este cel mai probabil dimensiunea ideală utilizată în scenariile practice. În comparație cu intrarea anterioară n = 1000, unde sortarea combinată bate sortarea inserției rulând de 10 ori mai rapid aici diferența este și mai semnificativă. Sortarea prin îmbinare bate sortarea inserției de 100 de ori! Algoritmul hibrid pe care l-am scris, de fapt, realizează sortarea tradițională de îmbinare rulând cu 0,01 secunde mai repede. Și, în sfârșit, funcția de bibliotecă qsort() ne demonstrează în sfârșit că implementarea joacă, de asemenea, un rol crucial în timp ce măsoară timpii de rulare cu meticulozitate, rulând cu 3 milisecunde mai rapid! :D
Notă: Nu rulați programul de mai sus cu n >= 10^6, deoarece va necesita multă putere de calcul. Mulțumesc și codare fericită! :)
Creați un test