1. SIMPLE Sorting Sorting is a typical operation to put the elements in an array in order. Internal Sorts [for small data sets] selection bubble (exchange) External Sorts [for large data sets]

2. Selection Sort index (k)sm_index 02 swap 21, 9 11 swap 13, 13 23 swap 21, 15 34 swap 21, 17 211591317 151791321 915211317 152191317 21159 17 Find smallest element, and put at the head of the list,repeat with remainder of list

3. Selection Sort void sort(double [5]); void swap(double [5], int, int);// prototypes void main(void) {int index; double my_list[ ] = {21, 13, 9, 15, 17}; sort(my_list); // function call cout<<"\nThe sorted array is: \n"; for(index=0; index<5; index++) cout<<'\t'<<my_list[index]<<endl; }

4. Selection Sort void sort(double testArray[5]) { int n, k, sm_index, moves=0;double smallest; for(k=0; k<4; k++) // size-1 = number of passes {smallest=testArray[k]; sm_index=k; for(n=k+1; n<5; n++) // size = # elem. to look at if(testArray[n]<smallest) {smallest=testArray[n]; sm_index=n; } swap(testArray, sm_index, k);// call to swap() }

5. Bubble Sort Put smaller first No change Put smaller first 212513917 2125 917 925211317 925132117

6. Bubble Sort Begin again and put smaller first No change Put smaller first 211791325 172191325 211713925 211791325

7. A Bubble Sort Function void bubble_sort(int array[ ], int length) { int j, k, flag=1, temp; for(j=1; j<=length && flag; j++) { flag=0; // false for(k=0; k < (length-j); k++) { if (array[k+1] > array[k]) // > low to high { temp=array[k+1]; // swap array[k+1]= array[k]; array[k]=temp; flag=1; // indicates a swap }}}} }}}} // has occurred

8. Insertion sort: Pick up the cards one at a time. When a card is picked up put it in the “already picked up list” in its correct position. *

9. G D Z F B E 0 1 2 3 4 5 Index number G D Z F B E 0 1 2 3 4 5 D G Z F B E 0 1 2 3 4 5 D G Z F B E 0 1 2 3 4 5 D F G Z B E 0 1 2 3 4 5 B D F G Z E 0 1 2 3 4 5 B D E F G Z 0 1 2 3 4 5

10. InsertionSort( int a[], int n) { int I; loc; temp; for (I = 1; I < n; I++) { temp = a[I]; loc = I; while (loc && (a[loc-1] > temp)) { a[loc] = a[loc-1]; -- loc; } a[loc] = temp; } GET NEXT ELEMENT TO INSERT Find its place in list -- keep moving items down until the correct locations is found

11. Insertion Sort Analysis: Worst case: O(n 2 ) 1+2+3+4+5….comparisons and moves for (I = 1; I < n; I++) { temp = a[I]; loc = I; while (loc && (a[loc-1] > temp)) { a[loc] = a[loc-1]; -- loc; } a[loc] = temp; BEST CASE? * O(n) Good for mostly sorted lists Average case = O(n 2 )

12. Using Pointers for Sorting In the algorithms looked at the data is physically re-arranged

13. Quicksort algorithm Split list into two “halves” one greater than the other now split each of these two lists

14. Elements………….. j Less than j Greater than j es < e>e <s>s cg m w c g m w abcdeDfFghjiklmosquvwyz

15. Partition Divide the list into two halves: left and right where the left half is smaller than the right: ----> use a “pivot” elements less than the pivot go left, elements greater than the pivot go right

16. 98 32 45 99 101 73 67 Pivot = 98 rightleft Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.

17. 98 32 45 99 101 73 67 Pivot = 98 67 32 45 99 101 73 67 right leftrightleft Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.

18. 98 32 45 99 101 73 67 Pivot = 98 67 32 45 99 101 73 67 right left 67 32 45 99 101 73 99 leftright Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.

19. 98 32 45 99 101 73 67 Pivot = 98 67 32 45 99 101 73 67 right left 67 32 45 99 101 73 99 leftright 67 32 45 73 101 73 99 leftright 67 32 45 73 98 101 99 left right Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.

20. int partition(int num[], int left, int right) {int pivot_val, temp; Pivot_val = num[left]; // "capture" the pivot value, which frees up one slot while (left < right) { // scan from right to left while(num[right] >= pivot_val && left < right) // skip over larger or equal val right--; if (right != left) { num[left] = num[right]; // move the higher value left++; } // scan from left to right while (num[left] <= pivot_val && left < right) // skip over smaller or equal val left++; if (right != left) { num[right] = num[left]; // move lower value into the available slot right--; } } num[left] = pivot_val; // move pivot into correct position return left; } // return the pivot index

21. #include using namespace std; int partition(int [], int, int); // function prototype int main() { const int NUMEL = 7; int nums[NUMEL] = {98,32,45,99,101,73,67}; int i, pivot; pivot = partition(nums, 0, NUMEL-1); cout << "\nThe returned pivot index is " << pivot; cout << "\nThe list is now in the order:\n"; for (i = 0; i < NUMEL; i++) cout << " " <<nums[i]; cout << endl; return 0; } The pivot index is 4 the list is now in the order: 67 32 45 73 98 101 99 *

22. Quicksort algorithm must call the partition algorithm until the “list is sorted”, I.e. on each half recursively until the “halves” are too small Quicksort algorithm: pick pivot & partition list call quicksort(left half) call quicksort (right half)

23. Elements………….. Quicksort(left)Quicksort(right)j Less than j Greater than j Q(left/left)Q(left/rgt) e Q(rgt/left)Q(rgt/rgt) s < e>e <s>s cg m w c g m w abcdeDfFghjiklmosquvwyz 14 calls to Quicksort

24. 98 32 45 99 101 73 67 Pivot = 98 67 32 45 99 101 73 67 right leftrightleft 67 32 45 99 101 73 99 leftright 67 32 45 73 101 73 99 leftright 67 32 45 73 98 101 99 left right After the partition with the pivot=98 98 is in its final position

25. 67 32 45 73 98 101 99 45 32 67 73 9899 101 32 45 Result of 1st partition 2nd and 3rd partition 4th partition

26. void quicksort(int num[], int lower, int upper) { int i, j, pivot; pivot = partition(num,lower, upper); if (lower < pivot) quicksort(num, lower, pivot - 1); if (upper > pivot) quicksort(num, pivot + 1, upper); return; }

27. #include using namespace std; void quicksort(int [], int, int); // function prototypes int partition(int [], int, int); int main() { const int NUMEL = 7; int nums[NUMEL] = {67,32,45,73,98,101,99}; int i; quicksort(nums, 0, NUMEL-1); cout << "\nThe sorted list, in ascending order, is:\n"; for (i = 0; i < NUMEL; i++) cout << " " <<nums[i]; cout << endl; return 0; }

28. Quicksort(nums, 0, 6) pivot (after partition = 2) Quicksort(nums, 0, 1) pivot (after partition = 1) Quicksort(nums, 0, 0) pivot (after partition = 0) Quicksort(nums, 3,6) pivot (after partition = 3) Quicksort(nums, 4,6) pivot (after partition = 4) Quicksort(nums, 5,6) pivot (after partition = 6) Quicksort(nums, 5,5) pivot (after partition = 5) 67 32 45 73 98 101 99 45 32 67 73 98 101 99 45 32 32 45 32 73 98 101 99 98 101 99 101 99 99 101 99

29. IN CLASS Assignment: Given the list of numbers below, write out the steps for the quicksort algorithm: 12 14 3 6 56 2 10 25 89 8

30. 8 10 3 6 2 12 56 25 89 14 Piv=12 2 6 3 8 10 12 14 25 56 89 Piv=8 Piv=56 Piv=2 Piv=14 2 6 3 8 10 12 14 25 56 89 2 3 6 8 10 12 14 25 56 89 Piv=6

31. Analysis of Quicksort: void quicksort(int num[], int lower, int upper) { int i, j, pivot; pivot = partition(num,lower, upper); if (lower < pivot) quicksort(num, lower, pivot - 1); if (upper > pivot) quicksort(num, pivot + 1, upper); Takes O(upper-lower) since every element must be compared to the pivot

32. Time(Quicksort(n)) = Partition(n) + Quicksort(n/2)+Quicksort(n/2) Best case time: O(n) Partition(n/2) + Quicksort(n/4) + Quicksort(n/4) + Partition(n/2) + Quicksort(n/4) + Quicksort(n/4) = O(n) + 2*O(n/2) + 4*(Quicksort(n/4) … = O(n) + O(n) + O(n) Log(n) times….. = O(nlogn)

33. Worst case time: 1 2 3 4 5 6 7 8 9 10 N times = O(n 2 )