Chapter 7 Sorting Part I

7.1 Motivation list: a collection of records. keys: the fields used to distinguish among the records. One way to search for a record with the specified key is to examine the list in left- to-right or right-to-left order. ◦ Sequential search.

Sequential Search To search the key ‘22’: int SeqSearch(int a[], int n, key) { int i; for (i=0; i<n && a[i] != key; i++) ; if (i >= n) return -1; return i; } int SeqSearch(int a[], int n, key) { int i; for (i=0; i<n && a[i] != key; i++) ; if (i >= n) return -1; return i; } The search makes n key comparisons when it is unsuccessful.

Analysis of Time Complexity Worst case: ◦ O(n) when the search is unsuccessful. ◦ Each element is examined exactly once. Average case: ◦ When the search is successful, the number of comparison depends on the position of the search key.

Binary Search int BinarySearch(int a[], int n, in key) { int left = 0, right = n-1; while (left <= right) { int middle = (left + right) / 2; if (key < a[middle]) right = middle - 1; else if (key > a[middle]) left = middle + 1; else return middle; } return -1; } int BinarySearch(int a[], int n, in key) { int left = 0, right = n-1; while (left <= right) { int middle = (left + right) / 2; if (key < a[middle]) right = middle - 1; else if (key > a[middle]) left = middle + 1; else return middle; } return -1; } leftrightmiddleTo find 23, middle found.

Binary Search Even when the search is unsuccessful, the time complexity is still O(log n). ◦ Something is to be gained by maintaining the list in an order manner.

Sorting Methods Internal: ◦ Can be carried out in memory.  Insertion sort.  Quick sort.  Merge sort.  Heap sort.  Radix sort. External: ◦ The dataset is much more bigger so the data cannot be fully carried out in memory.

7.2 INSERTION SORT

Idea Consider how to insert a new integer into a sorted array so that all the elements in the array are sorted

Insertion into a Sorted List Suppose a is an integer array with n elements. void Insert(int key, int a[], int i); ◦ Insert a new value, key, into the first i integers in a, where the first i integers should be sorted. void Insert(int key, int a[], int i) { int j; for (j = i-1; j >= 0 && key < a[j]; j--) a[j+1] = a[j]; a[j+1] = key; } void Insert(int key, int a[], int i) { int j; for (j = i-1; j >= 0 && key < a[j]; j--) a[j+1] = a[j]; a[j+1] = key; }

Insertion Sort At the i th iteration of this algorithm, the first i elements in the original array will be sorted i = a: temp: 1 i = 2 6 void InsertionSort(int key, int a[], int i) { for (j = 1; j < n; j++) int temp = a[j] Insert(temp, a, j-1); } void InsertionSort(int key, int a[], int i) { for (j = 1; j < n; j++) int temp = a[j] Insert(temp, a, j-1); }

Analysis of InsertionSort() Worst case ◦ As each new record is inserted into the sorted part of the list, the entire sorted part is shifted right by one position. j

Analysis of InsertionSort() In worst case, InsertSort() makes O(i) comparison before a[i] is inserted. For i=1, 2, …, n-1. The time complexity of InsertionSort() is ◦ In fact, insertion sort is about the fastest sorting method for small n (n ≦ 30).

Variations Binary Insertion Sort: ◦ To reduce the number of comparison. ◦ Therefore, apply binary search in Insert(). Linked Insertion Sort ◦ The elements of the list are represented as a linked list.  The number of record move can become zero because only link fields require adjustment.

7.3 QUICK SORT

Introduction Quick sort has the best average behavior among the sorting methods. Concept: a: pivot Find a pivot from a. pivot a’: ≧ pivot ≦ pivot Quick Sort Quick sort is essentially a recursive approach.

Definition left and right are used to indicate the scope of the array. ◦ left should be less than right; if not, return directly. a[left] is initially chosen as pivot left right pivot i j i: examined as index to scan the array from left to right. j: examined as index to scan the array from right to left. Initially, i = left, j=right+1.

Example left right pivot i j 5 > pivot and should go to the other side. 2 < pivot and should go to the other side. Interchange a[i] and a[j] 25 Stop. a[j] will eventually stop at a position where a[j] < pivot. Interchange a[j] and pivot. 144

Algorithm void QuickSort(int a[], int left, int right) { if (left < right) { pivot = a[left]; i = left; j = right+1; while (i < j) { for (i++; i<=j and a[i] < pivot; i++) ; for (j++; i>=j and a[i] >= pivot; i++) ; if (i < j) interchages a[i] amd [i]; } QuickSort(a, left, j-1); QuickSort(a, j+1 right;); } void QuickSort(int a[], int left, int right) { if (left < right) { pivot = a[left]; i = left; j = right+1; while (i < j) { for (i++; i<=j and a[i] < pivot; i++) ; for (j++; i>=j and a[i] >= pivot; i++) ; if (i < j) interchages a[i] amd [i]; } QuickSort(a, left, j-1); QuickSort(a, j+1 right;); }

Analysis of QuickSort() Best case ◦ If the pivot is correctly positioned (left size = right size), the time complexity is

Analysis of QuickSort() Worst case: ◦ Consider a list is stored.  The smallest one is always chosen as pivot.  n iterations are required to reach base case (left >= right).  Each iteration takes O(n) time.  The time complexity is O(n 2 ); 16425

Lemma 7.1 Let T avg (n) be the expect time for function QuickSort() to sort a list with n records. Then there exists a constant k such that T avg (n) ≦ knlog e n for n ≧ 2.

Lemma 7.1 Proof: ◦ Assume pivot is at j. ◦ The expected time to sort two sides is ◦ The average time is j j-1n-j where c is a constant.

Induction base: for n = 2 Induction hypothesis: ◦ Assume that Induction step