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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 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 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

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 → A A insert top 3 U > B, U > D, B < D X36DSA 2005

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 / 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 / 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 / 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 / 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 / 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 / 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 / 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 / 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… … make a heap here… … make a heap here X36DSA 2005

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 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 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 / 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 A A B B D D E E J J M M K K O O R R T T U U Z Z Not a heapUnsorted X36DSA 2005

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 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 D D E E J J K K M M O O R R T T U U Z Z B B A A D D E E J J K K M M O O R R T T U U Z Z B B A A Creating a heap X36DSA 2005

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 D D E E J J K K M M O O R R T T U U Z Z B B A A A A B B D D E E J J M M K K O O R R T T U U Z Z HeapCreating a heap X36DSA 2005

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 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 / 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 heapk Z Z U U Z Z K K X36DSA 2005

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 / 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 / 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)  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 / 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 / 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 / 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 / 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 / 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 / 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

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

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 / 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 / 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 / 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 / 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 / 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 / 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 B _ _ a _ _ b_ _ C_ _ D Cbb DaD aDb DCa CCC aDD DDb aDC bbC bab DbD Cba aCb UnsortedSort by 3 rd digit X36DSA 2005

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 B _ a _ _ b __ C __ D_ Cbb DaD aDb DCa CCC aDD DDb aDC bbC bab DbD Cba aCb Sorted by 3 rd digit Sort by 2 nd digit DCa Cba Cbb aDb DDb bab aCb CCC aDC bbC DaD aDD DbD X36DSA 2005

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 B a _ _ b _ _C _ _D_ _ 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 Sorted! X36DSA 2005

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 B _ _ a _ _ b _ _ C _ _ D DaD aDb DCa CCC aDD DDb aDC bbC bab DbD Cba aCb UnsortedSorted by 3 rd digit start & endnext a b C 6 Cbb D Array data structure 3 Example X36DSA 2005

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 / 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 / 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