Sorting Dr. Yingwu Zhu

Sorting Consider list x 1, x 2, x 3, … x n We seek to arrange the elements of the list in order Ascending or descending Some O(n 2 ) schemes easy to understand and implement inefficient for large data sets

Review: Selection Sort O(n^2) Make passes through a list/sublist On each pass reposition correctly some element. E.g., find the smallest item in the sublist and put it into a right position

Simple Selection Sort Algorithm Array-based Can you implement it? template void select_sort(T a[], int n); Q: What’s the computing time T(n)?

Simple Selection Sort Algorithm template void select_sort(int a[], int n) { for (int i=0; i a[j]) min_pos = j; } if (min_pos != i) { T temp = a[i]; a[i] = a[min_pos]; a[min_pos] = temp; } } T(n) = ?

Simple Selection Sort Algorithm Linked List-based template void select_sort(T* head);

Simple Selection Sort Algorithm template void selection_sort(T* head) { while (head) { T* ptr = head->next; while (ptr) { if (head->data > ptr->data) { T temp = head->data; head->data = ptr->data; ptr->data = temp; } ptr = ptr->next; } head = head->next; }

Simple Selection Sort Algorithm Linked List-based Why not move the nodes around? If we wanna move the nodes around, what more should we do? What difference from array-based?

Review of Exchange Sort Systematically interchange pairs of elements which are out of order Bubble sort does this Out of order, exchange In order, do not exchange

Bubble Sort void bubble_sort(int a[], int n) Can you write one in C++ function?

Bubble Sort void bubble_sort(int a[], int n) { int num_compares = n-1; //first should do n-1 comparisons while (num_compares > 0) { int last = 0; //why need this? for (int i=0; i<num_compares; i++) { if (a[i] > a[i+1]) { swap(a[i], a[i+1]); last = i; } //end if num_compares = last; } //end while } // thinking: why need last = i??? The purpose of last?

Bubble Sort Algorithm What is the worst case for Bubble Sort? The list of items are in decreasing order. T(n) = O(n^2)

Bubble Sort Disadvantage? Swap of data items, but if data item is large, swap could be very inefficient Advantage over selection sort? Does not need to pass through the whole list if the list is partially sorted. It can detect it.

Insertion Sort Repeatedly insert a new element into an already sorted list Note this works well with a linked list implementation Why not good for arrays? Dynamic sorting algorithm

Example of Insertion Sort Given list to be sorted 67, 33, 21, 84, 49, 50, 75 Note sequence of steps carried out

Algorithm for Linear Insertion Sort Can you write one in C++ function? void insertion_sort(int a[], int n)

Algorithm for Linear Insertion Sort void insertion_sort(int a[], int n) { int temp; for (int i = 1; i<n; i++) { temp = a[i]; // keep the item to be inserted for (int j = i-1; j >= 0; j--) //go through the sorted sublist if (temp < a[j]) a[j+1] = a[j]; //shift the items else break; a[j+1] = temp; } //end for }

Algorithm for Linear Insertion Sort T(n) = ? If we use a linked-list instead of an array, how do we adapt the previous code? Write a linked-list based one Do you know the difference?

Can we have better Sorting Algorithms We seek improved computing times for sorts of large data sets, better than O(n^2) Chapter presents schemes (e.g. heapsort) which can be proven to have average computing time O( n log 2 n ) Must be said, no such thing as a universally good sorting scheme Results may depend just how out of order list is

Comparison of Sorts Sort of a randomly generated list of 500 items ( Note: times are on 1970s hardware) AlgorithmType of SortTime (sec) Simple selection Heapsort Bubble sort 2 way bubble sort Quicksort Linear insertion Binary insertion Shell sort Selection Exchange Insertion

Indirect Sorts Possible that the items being sorted are large structures Data transfer/swapping time unacceptable Alternative is indirect sort Uses index table to store positions of the objects Manipulate the index table for ordering Where will this technique be used? Name one

Question?