Data Structures and Algorithms I Sorting CMP 338 Data Structures and Algorithms I Sorting

Selection Sort Worst-case: ~N2/2 <'s; ~N <=>'s public static void sort(Comparable[] a) int N = a.length for (int i=0; i<N; i++) int min=i for (int j=i+1; j<N; j++) if (a[j] < a[min]) min=j exch(a, i, min) Worst-case: ~N2/2 <'s; ~N <=>'s Average-case: ~N2/2 <'s; ~N <=>'s Best-case: ~N2/2 <'s; ~N <=>'s Not recommended unless <=>'s are very expensive

Insertion Sort Worst-case: ~N2/2 <'s; ~N2/2 <=>'s public static void sort(Comparable[] a) int N = a.length for (int i=0; i<N; i++) for (int j=i; 0<j && a[j]<a[j-1]; j--) exch(a, j, j-1) Worst-case: ~N2/2 <'s; ~N2/2 <=>'s Average-case: ~N2/4 <'s; ~N2/4 <=>'s Almost sorted: ~cN <'s; ~c'N <=>'s Stable, acceptable, if N is small or a is almost sorted

Shell Sort Worst-case: ~cN2 <'s; ~c'N2 <=>'s public static void sort(Comparable[] a) int N=a.length; h=1; while(h<N/3) h=3h+1 while(1<=h) for (int i=h; i<N; i++) for (int j=i; h<=j&&a[j]<a[j-h]; j-=h) exch(a, j, j-1) h /= 3 Worst-case: ~cN2 <'s; ~c'N2 <=>'s Average-case: ~cN1.5 <'s; ~N1.5/4 <=>'s Almost sorted: ~(c+k)N <'s; ~(c'+k)N <=>'s Acceptable, unless N is very big or sort called often

Merge Sort Worst-case: ~N lg N <'s; ~6N lg N array accesses sort(Comparable[] a, int lo, int hi) if (hi<=lo) return; int mid = lo + (hi-lo)/2 sort(a, lo, mid) sort(a, mid+1, hi) merge(a, lo, mid, hi) Worst-case: ~N lg N <'s; ~6N lg N array accesses Average-case: ~N lg N <'s; ~6N lg N array accesses Almost sorted: ~N lg N <'s; ~6N lg N array accesses Stable; acceptable, unless scratch space is an issue

Merge merge(Comparable[] a, int lo, mid, hi) int i=lo; j=mid+1 for (int k=lo; k<=hi; k++) aux[k] = a[k] for (int k=lo; k<=hi; k++) if (mid<i) a[k]=aux[j++] else if (hi<j) a[k]=aux[i++] else if (aux[j]<aux[i]) a[k]=aux[j++] else a[k]=aux[i++]

Quick Sort Worst-case: ~ N2/2 <'s; sort(Comparable[] a) StdRandom.shuffle(a); sort(a, 0, ||a||-1) sort(Comparable[] a, int lo, int hi) if (hi<=lo) return; int j = partition(a, lo, hi) sort(a, lo, j-1) sort(a, j+1, hi) Worst-case: ~ N2/2 <'s; Average-case: ~ 2N lg N <'s; ~ N lg N / 3 <=>'s Preferred, unless worst-case would be a disaster

Partition int partition(Comparable[] a, int lo, hi) int i=lo, j=hi+1 while (true); while (a[++i] < a[lo]) if (i==hi) break // necessary, why? while (a[lo] < a[--j]) if (j==lo) break // unnecessary, why? if (j<=i) exch(a, lo, j); return j exch(a, i, j)

Heap Sort Worst-case: ~ 2N lg N <'s; ~ N lg N <=>'s sort(Comparable[] a) MaxPQ pq = new MaxPQ() for (int i=0; i<||a||; i++) pq.insert(a[i]) for (int i=||a||-1; 0<=i; i--) a[i] = pq.delMax() Worst-case: ~ 2N lg N <'s; ~ N lg N <=>'s Average-case: ~ 2N lg N <'s; ~ N lg N <=>'s Perfectly acceptable, no extra space required Quicksort and Merge sort may be slightly faster

Heap Sort in an Array Build heap Find min element and swap with index 0 int N = ||a||-1 for j=N; 0<j; j-- (~ cN, why?) sink(j) Create sorted array while 0<N (~ cN lg N) exch(1, --N) sink(1)

Sink and Swim in an Array Indices of children of node at index i: 2i and 2i+1 Root index is 1 (not 0) swim (int k) while i<k && a[k] < a[k/2] exch(k/2, k); k = k/2 sink(int k) while 2*k <= N j = 2*k if j<N && a[j] < a[j+1] j++ exch(j, k); k = j