Chapter 24. Sorting. Objectives. 1. To study and analyze time efficiency of various sorting algorithms

Transcription

1 Chapter 4 Sortig 1 Objectives 1. o study ad aalyze time efficiecy of various sortig algorithms o desig, implemet, ad aalyze bubble sort o desig, implemet, ad aalyze merge sort o desig, implemet, ad aalyze quick sort o desig ad implemet a heap o desig, implemet, ad aalyze heap sort o desig, implemet, ad aalyze bucket sort ad radix sort o desig, implemet, ad aalyze exteral sort for large data i a file 4.7.

2 why study sortig? Sortig is a classic subject i computer sciece. here are three reasos for studyig sortig algorithms. First, sortig algorithms illustrate may creative approaches to problem solvig ad these approaches ca be applied to solve other problems. Secod, sortig algorithms are good for practicig fudametal programmig techiques usig selectio statemets, e ts, loops, methods, ad arrays. ays hird, sortig algorithms are excellet examples to demostrate algorithm performace. 3 what data to sort? For simplicity, this sectio assumes: 1. data to be sorted are itegers,. data are sorted i ascedig order, ad 3. data are stored i a array. he programs ca be easily modified to sort other types of data, to sort i descedig order, or to sort data i a ArrayList or a LikedList. 4

3 Bubble Sort public class BubbleSort { /** Bubble sort method */ public static void bubblesortit[] list { boolea eednextpass = true; for it k = 1; k < list.legth && eednextpass; k++ { // Array may be sorted ad ext pass ot eeded eednextpass = false; for it i = 0; i < list.legth k; i++ { if list[i] > list[i + 1] { // Swap list[i] with list[i + 1] it temp = list[i]; list[i] = list[i + 1]; list[i + 1] = temp; eednextpass = true; // Next pass still eeded 5 K elemets are i their correct positio. Bubble Sort temp k list[0] list[1] list[i] List[i+1] list[ ] list[ 1] if list[i] > list[i+1] swaplist, i, i+1 6

4 Bubble Sort a 1st pass b d pass c 3rd pass d 4th pass e 5th pass Bubble sort time: O 7 public class MergeSort { Merge Sort Algorithm 1 of /** Divide & Coquer method for sortig the umbers i give array */ public static void mergesortit[] list { if list.legth > 1 { // Merge sort the first half it[] firsthalf = ew it[list.legth / ]; System.arraycopylist, 0, firsthalf, 0, list.legth / ; mergesortfirsthalf; // Merge sort the secod half it secodhalflegth = list.legth list.legth / ; it[] secodhalf = ew it[secodhalflegth]; System.arraycopylist, list.legth /, secodhalf, 0, secodhalflegth; mergesortsecodhalf; // Merge firsthalf with secodhalf it[] temp = mergefirsthalf, secodhalf; System.arraycopytemp, 0, list, 0, temp.legth; 8

5 Merge Sort Algorithm of /** Merge two sorted lists */ private static it[] mergeit[] list1, it[] list { it[] temp = ew it[list1.legth + list.legth]; it curret1 = 0; // Curret idex i list1 it curret = 0; // Curret idex i list it curret3 = 0; // Curret idex i temp while curret1 < list1.legth && curret < list.legth { if list1[curret1] < list[curret] temp[curret3++] = list1[curret1++]; else temp[curret3++] = list[curret++]; while curret1 < list1.legth l temp[curret3++] = list1[curret1++]; while curret < list.legth temp[curret3++] = list[curret++]; retur temp; //merge 9 Merge Sort split split split merge merge divide coquer merge

6 Merge wo Sorted Lists curret1 curret curret1 curret curret1 curret curret3 a After movig 1 to temp curret3 b After movig all the elemets i list to temp curret3 c After movig 9 to temp 11 Merge Sort ime Let deote the time required for sortig a array of elemets usig merge sort. Without loss of geerality, assume is a power of. he merge sort algorithm splits the array ito two subarrays, sorts the subarrays usig the same algorithm recursively, ad the merges the subarrays. So, mergetime 1

7 Merge Sort ime mergetime he first / is the time for sortig the first half of the array ad the secod / is the time for sortig the secod half. o merge two subarrays, it takes at most 1 comparisos to compare the elemets from the two subarrays ad moves to trasfer elemets to the temporary array. So, the total time is 1. herefore, 13 Merge Sort ime log 1 log 1 log 1 log log, 1 log log log log O k assume k k k k k k k

8 Merge Sort ime 15 Quick Sort Quick sort, developed by C. A. R. Hoare 196, works as follows: 1. he algorithm selects a elemet, called the pivot, i the array.. Divide the array ito two parts such that all the elemets i the first part are less tha or equal to the pivot ad all the elemets i the secod part are greater tha the pivot. 3. Recursively apply the quick sort algorithm to the first part ad the the secod part. 16

9 public class QuickSort { // helper method public static void quicksortit[] list { quicksortlist, 0, list.legth 1; Quick Sort private static void quicksortit[] list, it first, it last { if last > first { it pivotidex = partitiolist, first, last; quicksortlist, first, pivotidex 1; quicksortlist, pivotidex + 1, last; 17 /** Partitio the array list[first..last] */ private static it partitioit[] list, it first, it last { it pivot = list[first]; // Choose the first elemet as the pivot it low = first + 1; // Idex for forward search it high = last; // Idex for backward search Quick Sort while high > low { // Search forward from left while low <= high && list[low] <= pivot low++; // Search backward from right while low <= high h && list[high] h] > pivot high ; // Swap two elemets i the list if high > low { it temp = list[high]; list[high] = list[low]; list[low] = temp; while high > first && list[high] >= pivot high ; // Swap pivot with list[high] if pivot > list[high] { list[first] = list[high]; list[high] = pivot; retur high; else { retur first; 18

10 Quick Sort pivot a he origial array pivot pivot bhe origial array is partitioed pivot pivot c he partial array is partitioed d he partial array is partitioed 1 3 e he partial array 1 3 is partitioed 19 Quick Sort Origial list [0]:5 [1]: []:9 [3]:3 [4]:8 [5]:4 [6]:0 [7]:1 [8]:6 [9]:7 Pivot:5 First:0 High:9 04 0:4 1 1: 1 :1 3:3 33 4:0 40 PIVO-5: :8 79 7:9 8:6 86 9:7 97 Pivot:4 First:0 High:4 0:0 1: :1 3:3 PIVO-4:4 Pivot:0 First:0 High:3 PIVO-0:0 1: :1 3:3 Pivot: First:1 High:3 1:1 PIVO-: 3:3 Pivot:8 First:6 High:9 6:6 7:7 PIVO-8:8 9:9 Pivot:6 First:6 High:7 PIVO-6:6 7:7 Sorted list [0]:0 [1]:1 []: [3]:3 [4]:4 [5]:5 [6]:6 [7]:7 [8]:8 [9]:9 0

11 Partitio pivot low high pivot low high pivot low high a Iitialize pivot, low, ad high b Search forward ad backward c 9 is swapped with 1 pivot low high d Cotiue search pivot low high e 8 is swapped with 0 pivot low high f whe high < low, search is over pivot g pivot is i the right place he idex of the pivot is retured 1 Quick Sort ime o partitio a array of elemets, it takes 1 comparisos pivot vs. all other ad moves i the worst case. So, the time required for partitio is O.

12 Quick Sort: Worst Case ime I the worst case, each time the pivot divides the array ito oe big subarray with the other empty. py he size of the big subarray is oe less tha the oe before divided. he algorithm requires O time: O 3 Quick Sort: Best Case ime I the best case, each time the pivot divides the array ito two parts of about the same size. Let deote the time required for sortig a array of elemets usig quicksort. herefore, O log 4

13 Quick Sort: Average Case ime O the average, each time the pivot will ot divide the array ito two parts of the same size or oe empty part. Statistically, the sizes of the two parts are very close. So the average time is Olog. he exact average-case aalysis is beyod the scope of this book. 5 Heaps Heap is a useful data structure for desigig efficiet sortig algorithms ad priority queues. A heap is a biary tree with the followig properties: 1. It is a complete biary tree.. Each ode is greater tha or equal to ay of its childre. 6

14 Complete Biary ree A biary tree is complete if every level of the tree is full except that the last level may ot be full ad all the leaves o the last level are placed left most. For example, i the figure below, the biary trees i a ad b are complete, but the biary trees i c ad d are ot complete. Further, the biary tree i a is a heap, but the biary tree i b is ot a heap, because the root 39 is less tha its right child a b c d 7 Represetig a Heap Usig a Array Node positio Paret Left Child Example. he ode for elemet 39 is at positio 4, so its left child elemet 14 is at.. 9 *4+1, its right child elemet 33 is at 10 *4+, ad its paret elemet 4 is at 1 4 1/. Right Child i i 1 / i + 1 i + 6 [0] [1] [] [3] [4] [5] [6] [7] [8] [9] [10][11][1][13] paret left right

15 Addig Elemets to a Heap Addig 3, 5, 1, 19, 11, ad to a heap, iitially empty a After addig 3 b After addig 5 c After addig d After addig e After addig f After addig 9 Addig Elemets to a Heap 1. Add ew ode to the ed of the heap. Rebuild heap as follows Let last ode be the curret ode; While the curret ode is greater tha its paret { Swap the curret ode with its paret; 30

16 Rebuild the heap after addig a ew ode Addig 88 to the heap a Add 88 to a heap b After swappig 88 with b After swappig 88 with 31 Removig the Root ad Rebuild the ree Remove the root maximum value i the heap Rebuild heap as follows: Move the last ode to replace the root; Let the ew root be the curret ode; Whilethe curret ode has childre ad the curret ode is smaller tha oe of its childre { Swap the curret ode with the larger childre; 3

17 Removig the Root ad Rebuild the ree Removig root 6 from the heap Removig the Root ad Rebuild the ree Move 9 to root

18 Removig the Root ad Rebuild the ree Swap 9 with Removig the Root ad Rebuild the ree Swap 9 with

19 Removig the Root ad Rebuild the ree Swap 9 with he Heap Class Heap<E> -list: java.util.arraylist<e> +Heap +Heapobjects: E[] +addewobject: E: void +remove: E +getsize: it Creates a default empty heap. Creates a heap with the specified objects. Adds a ew object to the heap. Removes the root from the heap ad returs it. Returs the size of the heap. Note: his is NO a class i the Collectio Framework. You eed to implemet your ow perhaps usig a ArrayList to represet a biary tree 38

20 Heap Sort public class HeapSort { /** Heap sort method */ public static <E exteds Comparable> void heapsorte[] list { // Create a Heap of itegers Heap<E> heap = ew Heap<E>; // Add elemets to the heap for it i = 0; i < list.legth; i++ heap.addlist[i]; // Remove root elemet from the heap for it i = list.legth 1; i >= 0; i list[i] = heap.remove; Note: Heap is ot a primitive type, you must provide your ow versio. 39 Heap Sort ime Let h deote the height for a heap of elemets. Sice a heap is a complete biary tree, the first level has 1 ode, the secod level has odes, the k th level has k-1 odes, the h-1th level has h- odes, ad the h th level has at least oe ode ad at most h-1 odes. herefore, the height of a Heap is Olog. Sice the add method traces a path from a leaf to a root, it takes at most h steps to add a ew elemet to the heap. he it takes Olog to create a heap holdig elemets. Similar reasoig for the remove method, yieldig Olog. herefore Heap-Sort requires Olog time. 40

21 Bucket Sort ad Radix Sort he lower boud for geeral sortig algorithms is Olog. So, o sortig algorithms based o comparisos ca perform better tha Olog. However, if the keys are small itegers, you ca use bucket sort without havig to compare the keys. I geeral Bucket Sort complexity is the order of OK Where K depeds o the umber of buckets ad the size of the key 41 Radix Sort Uses 10 buckets ad a list of iput keys. 1. he i th digit of a key idicates the host bucket.. Begi with least sigificat key digit ad place list items i correspodig buckets. 3. Remove data from buckets to recostruct list. 4. Repeat with ext least sigificat digit util all key positios have bee used. Complexity of Radix Sort is Ok Where k is the umber of digits i the largest of the key values 4

22 Radix Sort Example: List = { 331, 454, 30, 034, 343, 045, 345, 059, 453, 345, 31, 009 Bucket Last radix Remove 30, 331, 31, 343, 453, 454, 034, 045, 345, 059, 009 Secod radix Remove 009, 30, 331, 31, 034, 343, 045, 345, 453, 454, 059 hird radix Remove 009, 034, 045, 059, 30, 31, 331, 343, 345, 453, Shell Sort 1. List-to-able: Arrage the data sequece i a two-dimesioal array of G colums begi with G list.legth/.. Sort the colums of the array 3. able-to-list: Recombie row-wise wise the table cells ito a liear data sequece. 4. Reduce Gap Size G G / 5. Repeat. he effect of the algorithm is that i each step the origial data sequece is progressively partially sorted. I each cycle the algorithm works with a smaller umber of colums. I the last step, the array cosists of oly oe colum. 44

23 Array to be sorted Gap= 4 a.legth/ = 8/ Shell Sort Gap= Gap: Sorted Array Shell Sort it[] a = {, 9, 5, 4, 8, 1, 6, 7; it gap = a.legth / ; while gap > 0 { for it i = gap; i < a.legth; i++ { it temp = a[i]; it j = i; while j >= gap && a[j - gap] > temp { a[j] = a[j - gap]; j -= gap; a[j] = temp; gap = it gap / ; 46

24 Shell Sort Aalysis Difficult to aalyze!!! he Gap sequece suggested by its ivetor Doald Shell was [1,,4,8,16,..., k ], leadig to O comparisos ad exchages i the worst case. A differet sequece [V. Pratt's] gives a algorithm i O log [ot as good as QuickSort s O log ] 47 Exteral Sort o sort data stored i a exteral file, you may first brig data to the memory, the sort it iterally. However, if the file is too large, all data i the file caot be brought to memory at oe time. 48

25 Exteral Sort Phase I Repeatedly brig data from the file to a array, sort the array usig a iteral sortig algorithm, ad output the data from the array to a temporary file. Program Origial file Array emporary file S 1 S S k 49 Phase II Merge a pair of sorted segmets e.g., S1 with S, S3 with S4,..., ad so o ito a larger sorted segmet ad save the ew segmet ito a ew temporary file. Cotiue the same process util oe sorted segmet results. S 1 S S 3 S 4 S 5 S 6 S 7 S 8 S 1, S merged S 3, S 4 merged S 5, S 6 merged S 7, S 8 merged S 1, S, S 3, S 4 merged S 5, S 6, S 7, S 8 merged S 1, S, S 3, S 4, S 5, S 6, S 7, S 8 merged Merge Merge Merge 50

26 Implemetig Phase II Each merge step merges two sorted segmets to form a ew larger segmet. he ew segmet doubles the umber elemets. he umber of segmets is reduced by half after each merge step. A segmet is too large to be brought to a array i memory. o implemet a merge step, 1. Copy half umber of segmets from file f1.dat to a temporary file f.dat.. he merge the first remaiig segmet i f1.dat with the first segmet i f.dat ito a temporary file amed f3.dat. 51 Implemetig Phase II S1 S S3 S4 S5 S6 S7 S8 f1.dat Copy to f.dat S 1 S S 3 S 4 f.dat S 1, S 5 merged S, S 6 merged S 3, S 7 merged S 4, S 8 merged f3.dat 5