Chapter 6 Sorting

Agenda Swapping two values in array of int Bubble sort O(n 2 ) Swapping/sorting an array of Object Swapping/sorting a Vector of Object Using Comparators Selection Sort O(n 2 ) Insertion SortO(n 2 ) QuicksortO(n log n) very efficient space Merge SortO(n log n) good for files Radix SortO(n) but not inefficient

Swapping Two Values—Array of Int public static void swap(int [] data, int i, int j) { int temp; temp = data[i]; data[i] = data[j]; data[j] = temp; }

Bubble Sort, array of int public static void bubbleSort (int [] data, int n) // pre: 0 <= n <= data.length // post: values in data[0..n-1] in ascending order { int numSorted = 0; // number of values in order int index; // general index while (numSorted < n) { // bubble a large element to higher array index for (index = 1; index < n-numSorted; index++) { if (data[index-1] > data[index]) swap(data,index-1,index); } // at least one more value in place numSorted++; }

Swapping Two String objects in Array public static void swap(String [] data, int i, int j) // pre: 0 <= i,j < data.length // post: data[i] and data[j] are exchanged { String temp; temp = i; i = j; j = temp; }

Bubble Sort, Array of String public static void bubbleSort ( String [] data, int n) // pre: 0 <= n <= data.length // post: values in data[0..n-1] in ascending order { int numSorted = 0; // number of values in order int index; // general index while (numSorted < n) { // bubble a large element to higher array index for (index = 1; index < n-numSorted; index++) { if (data[index-1].compareTo( data[index])>0) swap(data,index-1,index); } // at least one more value in place numSorted++; }

compareTo method required by Comparable interfaceComparable Standard method to compare two objects – Not in class Object however – each class must provide it – Returns a number zero Indicates obj1 obj2 StringString s1=input.next(), s2 = input.next(); if (s1.compareTo(s2)<0) System.out.println( s1 + “is less than ” + s2 ); if (s1.compareTo(s2)==0) System.out.println( s1 + “is same as ” + s2 ); if (s1.compareTo(s2)>0) System.out.println( s1 + “is greater than” + s2 );

Swapping Two (Generic) Objects in Array public static void swap(T[] data, int i, int j) // pre: 0 <= i,j < data.length // post: data[i] and data[j] are exchanged { T temp; temp = data[i]; data[i] = data[j]; data[j] = temp; }

Bubble Sort, Array of Generic Objects public static void bubbleSort (T[] data, int n) // pre: 0 <= n <= data.length // post: values in data[0..n-1] in ascending order { int numSorted = 0; // number of values in order int index; // general index while (numSorted < n) { // bubble a large element to higher array index for (index = 1; index < n-numSorted; index++) { if (data[index-1].compareTo( data[index])>0) swap(data,index-1,index); } // at least one more value in place numSorted++; }

Comparison Summary int, char, double, float: use,== generic objects: use.compareTo() – If provided – Locked in to the way compareTo is written What if – Class doesn’t have compareTo ? – Don’t like order compareTo uses? Use Comparator objects

ComparatorComparator Interface Requires compare method:

A comparator for Caseless String sort

WordFreq comparators class CompareByString implements Comparator > { public int compare(Association a, Association b){ String left = a.getKey(); String right = b.getKey(); return left.compareToIgnoreCase(right); } class CompareByInteger implements Comparator > { public int compare(Association a, Association b){ Integer left = a.getValue(); Integer right = b.getValue(); return -left.compareTo(right); }

Other Sort Algorithms Two costly operations in sorting: – Comparing two objects – Swapping two objects – Different algorithms trade off these operations in attempts to optimize for certain conditions

Selection Sort– find biggest  swap

Selection Sort Pro/Con Pros: O(n) swaps Cons: O(n 2 ) compares  O(n 2 ) overall Performance independent of ordering of data

Insertion Sort – put item in correct pos

Insertion Sort Pro/Con Cons: O(n 2 ) compares and data movement  O(n 2 ) overall Pros: ordered or nearly-ordered data  O(n) – Insertion sort is useful at tail end of Quicksort

Merge Sort core idea: merge

Full mergeSort algorithm (recursive)

Trace of mergeSortRecursive

Non-recursive mergeSort wrapper

Mergesort Pro/Con Pro: useful when data are in large files too big to load into memory – Files are split into manageable chunks, sorted, then merged Cons: extra overhead in memory needed for temp array.

Quicksort core idea: partition

Full quickSort method (recursive)

Quicksort Pro/Con Pro: very fast, O(n log n) for random order Con: terrible on nearly sorted, or reverse sorted data  O(n 2 ) – Sometimes insertion sort used when size <= 20

Radix Sort See text…!