Sorting

1. Sorting • A fundamental operation in computer science (many programs need to sort as an intermediate step). • Many sorting algorithms have been developed • Choose a criteria which is used to order data • Given a list of records that have keys, use those keys to define an ordering of the items in the list • To sort a set of data, the data have to be compared and moved as necessary. Thus, measure the efficiency of a sorting algorithm by: • Number of data comparisons it needs to perform • Number of data movements it needs to perform

2. Elementary Sorting Algorithms • given n items to sort • There are a number of simple sorting algorithms whose worst and average case time complexity is quadratic (i.e., O(n2)) • Insertion sort • Selection sort • Bubble sort

3. Insertion Sort • Given an array of data items: • The insertion sort algorithm views the array as having a sorted side and an unsorted side • The sorted side starts with the first element, which is not necessarily the smallest element • The sorted side grows by taking the front element from the unsorted side and inserting it in the place that keeps the sorted side arranged from small to large • In some cases there is no need to move the new inserted item

5. The Insertion Sort Algorithm template <class T> void insertionsort(T data[], int n){ for(int i=1, j; i<n; i++){ T tmp =data[i]; //take next key from unsorted part of array for (j =i; j>0 && tmp < data[j-1]; j--) //shift data down to make room for inserting tmp if necessary data[j] = data[j-1]; data[j] = tmp; //insert in appropriate location in sorted part of array } }

6. Complexity of Insertion Sort • Best case O(n) • Worst and average case O(n2)

7. Selection Sort • Basic idea: • Repeatedly select the smallest element and move this element to the front of the unsorted side

8. selectionsort template<class T> void selectionsort(T data[], int n) { int j; for (int i = 0, least, j; i < n-1; i++) { //find the index of the smallest element in the unsorted part of array for (j = i+1, least = i; j < n; j++) if (data[j] < data[least]) least = j; //put the ith smallest to the i-1th position swap(data[least],data[i]); } }

9. Selection Sort (cont’d) • Given an array of integers: • Start by finding the smallest element • Swap the smallest entry with the first element • Part of the array is sorted • Find the smallest element in the unsorted side • Swap with the front of the unsorted side • The size of the sorted side is increased by one element • Continue until the unsorted side has just one number.

11. selectionsort • complexity

12. BubbleSort • Given an array of integers: • Scan the array from right to left • Look at pairs of elements (adjacent elements) in the array and swap their order if needed (i.e., if the left element is larger than the right element) • Repeatedly scan the array from right to left looking at pairs of elements and swapping their order if needed • In this way, the smallest element is “bubbled” all the way to the first position of the array • Scan the array again from right to left to “bubble” the second smallest element to the second of the array • Continue scanning until done

13. bubblesort template<class T> void bubblesort(T data[], int n) { // n passes, each pass ”bubble” one element for (int i = 0; i < n-1; i++) //keep comparing adjacent elements for (int j = n-1; j > i; --j) if (data[j] < data[j-1]) swap(data[j],data[j-1]); }

14. BubbleSort • complexity

15. Elementary Sorting Algorithms • Selection Sort, Insertion Sort, and Bubble Sort all have a worst-case time of O(n2), making them impractical for large arrays • But they are easy to program, easy to debug • Insertion Sort also has good performance when the array is nearly sorted to begin with • But more sophisticated algorithms are needed when good performance is needed in all cases for large arrays • Heap Sort • Quick Sort • Merge Sort