1 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)),

Prezentace na téma: "1 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)),"— Transkript prezentace:

1 1 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA Různé algoritmy mají různou složitost X36DSA 2005

2 2 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA The complexity of different algorithms varies X36DSA 2005

3 3 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Stable sort Andrew Cook Amundsen Brown Barbara CharlesCook sorted Sort by family name only Amundsen Brown Cook Brown Charles Barbara Andrew Amundsen Charles Barbara Andrew Amundsen Cook Brown Barbara Charles Andrew Charles Andrew Barbara sorted X36DSA 2005

4 4 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Unstable sort Andrew Cook Amundsen Brown Barbara CharlesCook sorted Sort by family name only Amundsen Brown Cook Brown Charles Barbara Andrew Amundsen Charles Barbara AndrewAmundsen Cook Brown Barbara Charles Andrew Charles Andrew Barbara QuickSort sorted X36DSA 2005

5 5 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Sorting Heap Sort Řazení haldou X36DSA 2005

6 6 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap A A B B D D E E J J M M K K O O R R T T U U Z Z a a c c b b a a c c a a b b    Heap rule X36DSA 2005

7 7 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap a a c c b b a a Terminology...... predcessor, parent of b b c c b b c c...... successor, child of, a a...... předchůdce, rodič...... následník, potomek A A B B D D...... (heap) top...... vrchol (haldy) X36DSA 2005

8 8 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap in an array 1 2 3 4 5 6 7 8 9 10 11 12 A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J M M K K O O R R T T U U Z Z 5 109 1 6 2 7 3 8 4 1211 r r t t s s k 2k2k+1 r r s s t t Heap stored in an array k 2k 2k+1 succesors X36DSA 2005

9 D D E E K K 9 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Repair a heap A A B B D D E E J J M M K K O O R R T T U U Z Z B B J J M M O O R R T T Z Z Top removed (1) U U  Swap B ↔ U remove top last first → 1 1 2 2 A A insert top 3 U > B, U > D, B < D X36DSA 2005

10 10 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Repair a heap B B D D E E J J M M K K O O R R T T Z Z U U  Swap J ↔ U Top removed (2) B B D D E E J J M M K K O O R R T T Z Z U U  Swap K ↔ U A A A A insert top - continues 3 U > M, U > J, J < M U > K, U > R, K < R X36DSA 2005

11 11 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Repair a heap B B D D E E J J M M K K O O R R T T Z Z U U Top removed (3) Heap, OK A A insert top - done 3 X36DSA 2005

12 12 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Repair a heap Top removed II (1) B B D D E E J J M M K K O O R R T T Z Z U U D D J J M M K K O O R R T T Z Z U U E E R > J, R > D, D < J A A remove top 1 last first → 2 1  Swap D ↔ R insert top 3 B B A A X36DSA 2005

13 13 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Repair a heap D D J J M M K K O O R R T T Z Z U U E E  Swap E ↔ R D D J J M M K K O O R R T T Z Z U U E E Heap, OK Top removed II (2)Top removed II (3) insert top - continues B B A A R E 3 B B A A insert top - done 3 X36DSA 2005

14 14 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap Sort A A B B D D E E J J M M K K O O R R T T U U Z Z Sorted for (i = 0; i < n; i++) a[i] = “Remove top”; Create a heap Unsorted B B D D E E J J K K O O R R U U Z Z A A M M T T A A B B D D E E J J M M K K O O R R T T U U Z Z M M O O R R T T Z Z U U I IIIII IV B B D D E E J J A A K K X36DSA 2005

15 15 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap recursive property A A B B D D E E J J M M K K O O R R T T U U Z Z is a heap  is a heap and is a heap X36DSA 2005

16 16 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Create a heap A A B B Z Z heap not a heap Z > A or Z > B  Swap: Z ↔ min(A,B) Z > A or Z > B  Swap: Z ↔ min(A,B) X36DSA 2005

17 17 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Create a heap B B Z Z heap not a heap A A CF heap X36DSA 2005

18 18 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Create a heap A A B B D D E E J J M M K K O O R R T T U U Z Z 1 Make a heap here… 2 3 4 5 6 … make a heap here… … make a heap here. 32 4 5 6 1 X36DSA 2005

19 19 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap in an array 1 2 3 4 5 6 7 8 9 10 11 12 A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J M M K K O O R R T T U U Z Z 5 109 1 6 2 7 3 8 4 1211 r r t t s s k 2k2k+1 r r s s t t Heap stored in an array k 2k 2k+1 succesors X36DSA 2005

20 20 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Create a heap in an array D D E E J J K K M M O O R R T T U U Z Z B B A A 2 1 3 4 5 6 7 8 9 10 11 12 A A B B D D E E J J M M K K O O R R T T U U Z Z 5 10 9 1 6 2 7 3 8 4 12 11 Not a heapUnsorted 1 2 3 4 5 6 1 2 3 4 5 6 X36DSA 2005

21 21 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Create a heap in an array D D E E J J K K M M O O R R T T U U Z Z 2 1 3 4 5 6 7 8 9 10 11 12 A A B B D D E E J J K K M M O O R R T T U U Z Z A A B B D D E E J J K K M M O O R R T T U U Z Z B B A A 2 1 3 4 5 6 7 8 9 10 11 12 2 1 3 4 5 6 7 8 9 10 11 12 D D E E J J K K M M O O R R T T U U Z Z B B A A 2 1 3 4 5 6 7 8 9 10 11 12 D D E E J J K K M M O O R R T T U U Z Z B B A A 2 1 3 4 5 6 7 8 9 10 11 12 1 2 3 4 5 Creating a heap X36DSA 2005

22 22 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Create a heap in an array D D E E J J K K M M O O R R T T U U Z Z B B A A 2 1 3 4 5 6 7 8 9 10 11 12 D D E E J J K K M M O O R R T T U U Z Z B B A A 2 1 3 4 5 6 7 8 9 10 11 12 A A B B D D E E J J M M K K O O R R T T U U Z Z 5 10 9 1 6 2 7 3 8 4 12 11 6 HeapCreating a heap X36DSA 2005

23 23 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap sort A A B B D D E E J J M M K K O O R R T T U U Z Z Heap A A B B D D E E J J M M K K O O R R T T U U Z Z 1 2 3 4 5 6 7 8 9 10 11 12 A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J M M K K O O R R T T U U Z Z heap Step 1 X36DSA 2005

24 24 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap Sort A A B B D D E E J J M M K K O O R R T T U U Step k A A B B D D E E J J M M K K O O R R T T A A B B D D E E J J M M O O R R T T U U Z Z 1 2 3 4 5 6 7 8 9 10 11 12 heapk Z Z U U Z Z K K X36DSA 2005

25 25 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap Sort // array: a[1]...a[n] !!!! void heapSort(Item a[], int size) { int i, j, // create a heap for (i = size/2; i > 0; i--) repairTop(array, i, size); // sort for (i = size; i > 1; i--) { swap(a, 1, i); repairTop(array, 1, i-1); } X36DSA 2005

26 26 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap Sort // array: a[1]...a[n] !!!!!! void repairTop(Item a[], int top, int bott) { int i = top; // a[2*i] and a[2*i+1] int j = i*2; // are successors of a[i] Item topVal = a[top]; // try to find a successor < topVal if ((j a[j+1])) j++; // while (successors < topVal) // move successors up while ((j a[j])) { a[i] = a[j]; i = j; j = j*2; // skip to next successor if ((j a[j+1])) j++; } a[i] = topVal; // put the topVal } X36DSA 2005

27 27 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Heap Sort repairTop operation worst case...log 2 (n) (n=heap size) create a heap... log 2 (n/2) + log 2 (n/2+1) +... + log 2 (n)  (n/2)(log 2 (n)) =  (n·log(n)) sort... n-1 repairTop operations, worst case: n/2 repairTop operations log 2 (n) + log 2 (n-1) +... + 1  n · log 2 (n) =  (n·log 2 (n)) total... create heap + sort = Asymptotic complexity of Heap sort is  (n·log 2 (n)) It is not a stable sort X36DSA 2005 But even best case =  (n·log 2 (n))

28 28 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Sorting Merge Sort Řazení sléváním X36DSA 2005

29 29 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J M M K K O O R R T T U U Z Z A A A A B B Merge two sorted arrays Compare elements X36DSA 2005

30 30 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J Merge two sorted arrays – cont. X36DSA 2005

31 31 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J K K A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J K K M M A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J K K M M O O Merge two sorted arrays X36DSA 2005

32 32 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J K K M M O O R R A A B B D D E E J J M M K K O O R R T T U U Z Z A A B B D D E E J J K K M M O O R R T T U U Z Z Merge two sorted arrays - cont Sorted Copy the rest X36DSA 2005

33 33 / 2The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Divide & Conquer! Divide et Impera! The problem The solution The problem The solution Solve the subproblem their work our work Merge! Divide! X36DSA 2005

34 Process separatel y Sorted 34 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort A A B B D D E E J J K K M M O O R R T T U U Z Z A A B B D D E E J J K K M M O O R R T T U U Z Z B B K K M M T T U U Z Z A A D D E E J J O O R R A A B B D D E E J J M M K K O O R R T T U U Z Z Unsorted Divide! Process separately Conquer! Merge! Sort! X36DSA 2005

35 Sorted 35 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort B B K K M M T T U U Z Z A A D D E E J J O O R R A A B B D D E E J J M M K K O O R R T T U U Z Z Unsorted Divide! …………………… K K U U Z Z B B M M T T A A E E J J D D O O R R K K U U Z Z B B M M T T A A E E J J R R O O D D Merge! X36DSA 2005

36 36 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort void mergeSort (int a[], int aux[], int low, int high) { int half = (low+high)/2; int i; if (low >= high) return; // too small! // sort mergeSort(a, aux, low, half); // left half mergeSort(a, aux, half+1, high); // right half merge(a, aux, low, high); // merge halves // put result back to a for (i = low; i <= high; i++) a[i] = aux[i]; // optimization idea: /* swapArray(a, aux) */ // better to swap // references to a & aux! } X36DSA 2005

37 37 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort void merge(int in[], int out[], int low, int high) { int half = (low+high)/2; int i1 = low; int i2 = half+1; int j = low; // compare and merge while ((i1 <= half) && (i2 <= high)) { if (in[i1] <= in[i2]) { out[j] = in[i1]; i1++; } else { out[j] = in[i2]; i2++; } j++; } // copy the rest while (i1 <= half) { out[j] = in[i1]; i1++; j++; } while (i2 <= high) { out[j] = in[i2]; i2++; j++; } } X36DSA 2005

38 38 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort Asymptotic complexity  log 2 (n) times Divide!........ Asymptotic complexity of MergeSort is  (n·log 2 (n)) log 2 (n) times Merge!........  Divide!........  (1) operations Merge!........  (n) operations Total........  (n)·  (log 2 (n)) =  (n·log 2 (n)) operations X36DSA 2005

39 39 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Merge Sort Stability Divide!........ Does not move the elements Nepohybuje prvky Merge! ….... “ if (in[i1] <= in[i2]) { out[j] = in[i1]; …” process the left element first when merging equal values Zařaď nejprve levý prvek když slučuješ stejné hodnoty MergeSort is a stable sort X36DSA 2005

40 40 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Sorting Radix Sort Přihrádkové řazení X36DSA 2005

41 41 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Radix sort DaD DbD DCa aDb aDD CCC aDC DDb bab bbC aCb Cbb Cba 5 10 9 1 6 2 7 3 8 4 12 11 13 B _ _ a _ _ b_ _ C_ _ D Cbb DaD aDb DCa CCC aDD DDb aDC bbC bab DbD Cba 1 2 3 4 5 6 7 8 9 10 11 12 aCb 13 1 2 5 6 7 3 4 10 9 8 12 11 13 UnsortedSort by 3 rd digit X36DSA 2005

42 42 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Radix sort 5 10 9 1 6 2 7 3 8 4 12 11 13 B _ a _ _ b __ C __ D_ Cbb DaD aDb DCa CCC aDD DDb aDC bbC bab DbD Cba aCb 1 2 5 6 73 4 10 9 8 12 11 13 Sorted by 3 rd digit Sort by 2 nd digit DCa Cba Cbb aDb DDb bab aCb CCC aDC bbC DaD aDD DbD 12 3 4 5 6 7 8910 11 1213 X36DSA 2005

43 43 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Radix sort 5 10 9 1 6 2 7 3 8 4 12 11 13 B a _ _ b _ _C _ _D_ _ 1 2 5 6 7 3 4 10 9 8 12 11 13 Sorted by 2 nd digit Sort by 1 st digit DCa Cba Cbb aDb DDb bab aCb CCC aDC bbC DaD aDD DbD bab DaD Cba Cbb bbC DbD DCa aCb CCC aDb DDb aDC aDD 123 456 7 8 9 10 11 12 13 Sorted! X36DSA 2005

44 Example 44 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Radix sort implementation DaD DbD DCa aDb aDD CCC aDC DDb bab bbC aCb Cbb Cba 5 10 9 1 6 2 7 3 8 4 12 11 13 B _ _ a _ _ b _ _ C _ _ D DaD aDb DCa CCC aDD DDb aDC bbC bab DbD Cba 1 3 4 5 7 8 9 10 12 aCb 13 1 2 5 6 7 3 4 10 9 8 12 11 13 UnsortedSorted by 3 rd digit 2 6 11 start & endnext a b C 6 Cbb 4 1 5 2 12 13 9 11 1 2 3 4 5 6 7 8 9 10 11 12 13 D 7 12 8 11 10 9 0 13 0 0 0 3 Array data structure 3 Example X36DSA 2005

45 45 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … d digits............ d loops loop............ RadixSort never changes order of equal values d << n ..….  (n) operations Asymptotic complexity of RadixSort is (n)(n) Summary  (d·n) operations total............  (n) operations Přihrádkové řazení nemění pořadí stejných hodnot It is a stable sort X36DSA 2005

46 46 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA Různé algoritmy mají různou složitost X36DSA 2005

47 47 / 3The complexity of different algorithms varies: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … Různé algoritmy mají různou složitost: O(n), Ω(n 2 ), Θ(n·log 2 (n)), … DSA The complexity of different algorithms varies X36DSA 2005