Ch 14: Search and Sorting Yonglei Tao

Linear Search /** Finds a value in an array, using the linear search algorithm. @param v the value to search @return the index at which the value occurs, or -1 if it does not occur in the array */ public int search(int v) { for (int i = 0; i < a.length; i++) { if (a[i] == v) return i; } return -1;

Binary Search /** A class for executing binary searches through an array. */ public class BinarySearcher { private int[] a; Constructs a BinarySearcher. @param anArray a sorted array of integers public BinarySearcher(int[] anArray) { a = anArray; }

public int search(int v) { int low = 0; int high = a.length - 1; while (low <= high) { int mid = (low + high) / 2; if (a[mid] == v) return mid; else if (a[mid] < v) low = mid + 1; else high = mid - 1; } return -1;

Insertion Sort void insertionsort (int [] list) { for (int i = 1; i < list.length; i++) int temp = list[i]; for (int j = i; j >= 1 && temp < list[j-1]; j--) list[j] = list[j-1]; list[j] = temp; } Running time: O(n2)

Selection Sort void selectionsort (int[] list) { int min;         for (int i = 0; i < list.length - 1; i++)         {             min = i;             for (int j = i + 1; j < list.length; j++)                 if (list[j] < list[min])                     min = j;                    swap (list[min], list[i]);         }     } Running time: O(n2)

Performance of Selection Sort Milliseconds 10,000 786 20,000 2,148 30,000 4,796 40,000 9,192 50,000 13,321 60,000 19,299 * Obtained with a Pentium processor, 2 GHz, Java 6, Linux

Merge Sort int [] A = new int[50]; void merge ( int, int, int ); void mergeSort ( int left, int right ) { int mid; if ( left < right ) { mid = ( left + right ) / 2; mergeSort ( left, mid ); mergeSort ( mid + 1, right ); merge ( left, mid, right ); } Running time: O(n log n)

void merge ( int left, int mid, int right ) { int p = left, q = mid + 1, k = left, int [] B = new int[50]; while ( p <= mid && q <= right ) { if (A[p] <= A[q]) B[k++] = A[p++]; else B[k++] = A[q++]; } while ( p <= mid ) while ( q <= right ) for ( k = left; k <= right; k++ ) A[k] = B[k];

Merge Sort vs. Selection Sort O(n log n) O(n2) n Merge Sort (milliseconds) Selection Sort (milliseconds) 10,000 40 786 20,000 73 2,148 30,000 134 4,796 40,000 170 9,192 50,000 192 13,321 60,000 205 19,299

Merge Sort vs. Selection Sort (Cont.)

Interface Comparable public interface Comparable { public int compareTo (Object other); } obj1.compareTo(obj2) < 0 if obj1 < obj2 obj1.compareTo(obj2) == 0 if obj1 == obj2 obj1.compareTo(obj2) > 0 if obj1 > obj2

An Example public class Country implements Comparable<Country> { private String name; private double area; public Country (String aName, double anArea) { name = aName; area = anArea; } public String getName () { return name; } public double getArea () { return area; } public int compareTo (Country other) { // compare two countries by area if (area < other.area) return -1; if (area > other.area) return 1; return 0;

An Example (Cont.) import java.util.*; public class CountrySortTester { public static void main (String[] args) { ArrayList<Country> countries = new ArrayList<Country>(); countries.add (new Country("Uruguay", 176220)); countries.add (new Country("Thailand", 514000)); countries.add (new Country("Belgium", 30510)); Collections.sort(countries); // sort the array list by area for (Country c : countries) System.out.println(c.getName() + " " + c.getArea()); }

Discussion: Class Shape public abstract class Shape implements Comparable<Shape> { private String name; public abstract double area (); public Shape( String shapeName ) { name = shapeName; } final public boolean compareTo ( Shape other ) { return this.area() - other.area(); final public String toString () { return name + " of area " + area();

Discussion: Class Point public abstract class Point implements Comparable<Point> { private int x, y; … final public boolean compareTo ( Point other ) { }

Exercise: Insertion Sort on Objects How to modify the code below to sort a list of Country objects? void insertionsort (int [] list) { for (int i = 1; i < list.length; i++) int temp = list[i]; for (int j = i; j >= 1 && temp < list[j-1]; j--) list[j] = list[j-1]; list[j] = temp; }

Quick Sort public static void quickSort (Comparable[] data, int min, int max) { int pivot; if (min < max) pivot = partition (data, min, max); quickSort(data, min, pivot-1); quickSort(data, pivot+1, max); }

The Partition Method private static int partition (Comparable[] data, int min, int max) { Comparable pivot = data[min]; int left = min, right = max; while (left < right) { while (data[left].compareTo(pivot) <= 0 && left < right) left++; while (data[right].compareTo(pivot) > 0) right--; if (left < right) swap(data, left, right); } swap (data, min, right); return right;

Comparison of Sorting Algorithms