1. The Sorting Methods Lecture Notes 10

2. Sorts Many programs will execute more efficiently if the data they process is sorted before processing begins. – We first looked at a linear search it doesn’t care whether the data is sorted or not the algorithm starts at the first element in the vector, and looks at every element in the vector, in sequence, until it finds what it is looking for, or comes to the end of the vector – With small data sets this algorithm performs acceptably – If the data sets are of significant size, than performance can become unacceptable We have since looked at Binary Search, which improves performance, IF the data is sorted

3. Sorts If we know that a data set is sorted in some order (lowest to greatest, largest to smallest, highest priority to lowest priority), then we can write searches to take advantage of this fact. – If you have misplaced your calculator in the library in the afternoon, you do not have to retrace your steps from when you arrived on campus in the morning to find it – You start your search in the library – When looking up a phone number in the phone book, you do not start at page 1 and scan each page in sequence, until you find the name you are looking for

4. Sorting Comparison There are all kinds of sorts For our purposes a sort is a rearrangement of data into either ascending or descending order Fast SortsversusSlow Sorts O (N log 2 N)O (N 2 ) slow sorts are easy to code and sufficient when the amount of data is small

5. Bubble Sort - N 2 Sort Strategy – ‘bubble’ the smallest item to the left (slot 0) – ‘bubble’ the next smallest item to slot 1 – ‘bubble’ the third smallest item to slot 2 algorithm (for one pass) walk through the Vector if this item (in spot j) is smaller than the item in spot j-1 swap item in spot j with the item in spot j-1 code for (int j = count-1; j >= 0; j--) { if (nums[j] < nums[j-1]) { int temp = nums[j]; nums[j] = nums[j-1]; nums[j-1] = temp; }

6. Bubble Sort (con’t) This code for one pass finds the smallest element in the vector and puts it into slot 0 Now wrap this code in a loop that will find succeeding smaller elements and put them into the proper position in the Vector // outer for loop controls the spot that gets the appropriate smallest value for (int I=0; I<size-1;I++) for (int j = count-1; j >= 0; j--) { if (nums[j] < nums[j-1]) { int temp = nums[j]; nums[j] = nums[j-1]; nums[j-1] = temp; }

7. Selection Sort We have noticed that the most “expensive” part of the bubble sort is swapping (three lines of code to execute) A selection sort reduces the number of swaps until the end of each pass, when we know what the smallest remaining value is, and placing it appropriately Strategy – find the smallest item, and swap it with slot 0 – find the next smallest item and swap it with slot 1 – find the third smallest item and swap it with slot 2 algorithm (for one pass) walk through the Vector the first item is labeled the smallest Every other element is compared to the smallest if it is smaller, than it is labeled the smallest At the end of the walkthrough, the first is swapped with the smallest

8. Selection Sort (con’t) The algorithm for one pass finds the smallest element in the vector and puts it into slot 0 Now wrap this code in a loop that will find succeeding smaller elements and put them into the proper position in the Vector // outer for loop controls the spot that gets the appropriate smallest // value (same as bubble sort) for (int left = 0; left < count - 1; left++) { // last one will be correct int smallest = left;// we will keep the index to the smallest for (int j = left + 1; j < count; j++) if (nums[j] < nums[smallest] { smallest = j; } if (smallest != left) // no sense swapping if left is smallest { int temp = nums[smallest]; nums[smallest] = nums[left]; nums[left] = temp; }

9. Use FindSmallest() routine with SelectionSort() We have spent a lot of time looking at FindSmallest() routines… you should know how to do that Incorporate that knowledge into selection sort // outer for loop controls the spot that gets the appropriate smallest // value (same as bubble sort) for (int left = 0; left < count - 1; left++) { int smallest = findSmallest(nums, count, left); // use what we already know // pass the starting point of the // remainder of the vector to look at if (smallest != left ) { int temp = nums[smallest]; nums[smallest] = nums[left]; nums[left] = temp; }

10. findSmallest(const int nums[], int count, int left); int findSmallest(const int nums[], int count, int left) { int smallest = left; // start with first index as the smallest for (int j = left + 1; j < count; j++) if (nums[j] < nums[smallest] { smallest = j; } return smallest; }

11. Quick Sort Most widely used algorithm Invented in 1960 by C.A.R. Hoare Not difficult to implement Good general purpose sort (works well in most cases) Average performance is n log n Recursive (drawback) Worst case performance is n 2 (why is that????) – file already sorted time = n 2 /2 and space = n precise mathematical analysis backed up by empirical results Divide and conquer algorithm

12. Quick Sort Algorithm – Partitioning Step Choose a pivot element say a = v[j] Determine its final position in the sorted array – a > v[I] for all I < j – Recursive Step – a j Perform above step on left array and right array An early look at quicksort code (incomplete) void quicksort(int[] A, int left, int right) { int I; if (right > left) { Pivot(A, left, right); I = partition(A, left, right); quicksort(A, left, I-1); quicksort(A, I+1, right); }

13. Quick Sort Code ctd.. More Detailed look at the partition code // Partition(): rearrange A into 3 sublists, a sublist // A[left] Ö A[j-1] of values at most A[j], a sublist A[j], // and a sublist A[j+1] Ö A[right] of values at least A[j] int Partition(int[] A, int left, int right) { if (A[left] > A[right]) swap(A[left], A[right]); char pivot = A[left]; int i = left; int j = right+1; do { do ++i; while (A[i] < pivot); do --j; while (A[j] > pivot); if (i < j) { Swap(A[i], A[j]); } } while (i < j); Swap(A[j], A[left]); return j; }

14. Quick Sort Code ctd.. More Detailed look at the pivot code // Pivot(): prepare A for partitioning void Pivot(int[] A, int left, int right) { if (A[left] > A[right]) Swap(A[left], A[right]); } eg: trace the quick sort code for 30 12 23 10 28 See demo folder for sample code

15. Quick Sort Analysis Divide the file by half Recurrence relation is – C(n) = 2C(n/2) + n – 2C(n/2) is the cost of doing two partitions of size n/2 – n is the cost of examining each element Using the above recurrence relation, prove that quick sort is of n log n Let us assume that n = 2 k for some k without the loss of generality C(n)= 2C(n/2) + n = 2 (2C(n/4) + n/2) + n = 2 (2(2C(n/8)+n/4) + n/2) + n = 2 3 C(n/2 3 ) + 3 n ….. After 3 iterations So after k iterations we have C(n) = 2 k C(n/2 k ) + k. n = 2 k C(1) + k. n since n = 2 k = 2 log n. 1 + k.n = n + n log n = f(n log n)