CHAPTER 18 SORTING AND SEARCHING. CHAPTER GOALS To study the several searching and sorting...

transcript

CHAPTER 18

SORTING AND SEARCHING

CHAPTER GOALS• To study the several searching and sorting

algorithms

• To appreciate that algorithms for the same task can differ widely in performance

• To understand big-Oh notation

• To learn how to estimate and compare the performance of algorithms

• To learn how to measure the running time of a program

Sorting an Array of Integers

• The selection sort algorithm repeatedly finds the smallest element in the unsorted tail region of the array and moves it to the front

• Array in original order

• Find the smallest and swap it with the first element

11 9 17 5 12

5 9 17 11 12

• Find the next smallest. It is already in the correct place

• Find the next smallest and swap it with the first element of unsorted portion

5 9 17 11 12

5 9 11 17 12

• Repeat

• When the unsorted portion is of

length 1, we are done

5 9 11 12 17

File SelectionSorter.java 01: /**

02: This class sorts an array, using the selection sort

03: algorithm

04: */

05: public class SelectionSorter

07: /**

08: Constructs a selection sorter.

09: @param anArray the array to sort.

10: */

11: public SelectionSorter(int[] anArray)

13: a = anArray;

16: /**

17: Sorts the array managed by this selection sorter.

18: */

19: public void sort()

21: for (int i = 0; i < a.length - 1; i++)

23: int minPos = minimumPosition(i);

24: swap(minPos, i);

28: /**

29: Finds the smallest element in a tail range of the array

30: @param from the first position in a to compare

31: @return the position of the smallest element in the

32: range a[from]...a[a.length - 1]

33: */

34: private int minimumPosition(int from)

36: int minPos = from;

37: for (int i = from + 1; i < a.length; i++)

38: if (a[i] < a[minPos]) minPos = i;

39: return minPos;

42: /**

43: Swaps two entries of the array.

44: @param i the first position to swap

45: @param j the second position to swap

46: */

47: private void swap(int i, int j)

49: int temp = a[i];

50: a[i] = a[j];

51: a[j] = temp;

54: private int[] a;

File SelectionSortTest.java 01: /**

02: This program tests the selection sort algorithm by

03: sorting an array that is filled with random numbers.

04: */

05: public class SelectionSortTest

07: public static void main(String[] args)

09: int[] a = ArrayUtil.randomIntArray(20, 100);

10: ArrayUtil.print(a);

12: SelectionSorter sorter = new SelectionSorter(a);

13: sorter.sort();

File ArrayUtil.java01: import java.util.Random;

03: /**

04: This class contains utility methods for array

05: manipulation.

06: */

07: public class ArrayUtil

09: /**

10: Creates an array filled with random values.

11: @param length the length of the array

12: @param n the number of possible random values

13: @return an array filled with length numbers between

14: 0 and n-1

15: */

16: public static int[] randomIntArray(int length, int n)

17: { int[] a = new int[length];

18: Random generator = new Random();

20: for (int i = 0; i < a.length; i++)

21: a[i] = generator.nextInt(n);

23: return a;

26: /**

27: Prints all elements in an array.

28: @param a the array to print

29: */

30: public static void print(int[] a)

33: System.out.print(a[i] + " ");

34: System.out.println();

Profiling the Selection Sort Algorithm

• We want to measure the time the algorithm takes to execute

o Exclude the time the program takes to load o Exclude output time

• Create a StopWatch class to measure execution time of an algorithm

o It can start, stop and give elapsed time

o Use System.currentTimeMillis method

• Create a Stopwatch object o Start the stopwatch just before the sort

o Stop the stopwatch just after the sort o Read the elapsed time

File StopWatch.java01: /**

02: A stopwatch accumulates time when it is running. You can

03: repeatedly start and stop the stopwatch. You can use a

04: stopwatch to measure the running time of a program.

05: */

06: public class StopWatch

08: /**

09: Constructs a stopwatch that is in the stopped state

10: and has no time accumulated.

11: */

12: public StopWatch()

14: reset();

17: /**

18: Starts the stopwatch. Time starts accumulating now.

19: */

20: public void start()

22: if (isRunning) return;

23: isRunning = true;

24: startTime = System.currentTimeMillis();

27: /**

28: Stops the stopwatch. Time stops accumulating and is

29: is added to the elapsed time.

30: */

31: public void stop()

33: if (!isRunning) return;

34: isRunning = false;

35: long endTime = System.currentTimeMillis();

36: elapsedTime = elapsedTime + endTime - startTime;

39: /**

40: Returns the total elapsed time.

41: @return the total elapsed time

42: */

43: public long getElapsedTime()

45: if (isRunning)

47: long endTime = System.currentTimeMillis();

48: elapsedTime = elapsedTime + endTime - startTime;

49: startTime = endTime;

51: return elapsedTime;

54: /**

55: Stops the watch and resets the elapsed time to 0.

56: */

57: public void reset()

59: elapsedTime = 0;

60: isRunning = false;

63: private long elapsedTime;

64: private long startTime;

65: private boolean isRunning;

File SelectionSortTimer 01: import javax.swing.JOptionPane;

03: /**

04: This program measures how long it takes to sort an

05: array of a user-specified size with the selection

06: sort algorithm.

07: */

08: public class SelectionSortTimer

12: String input = JOptionPane.showInputDialog(

13: "Enter array size:");

14: int n = Integer.parseInt(input);

16: // construct random array

18: int[] a = ArrayUtil.randomIntArray(n, 100);

19: SelectionSorter sorter = new SelectionSorter(a);

21: // use stopwatch to time selection sort

23: StopWatch timer = new StopWatch();

25: timer.start();

26: sorter.sort();

27: timer.stop();

29: System.out.println("Elapsed time: "

30: + timer.getElapsedTime() + " milliseconds");

31: System.exit(0);

Selection Sort on Various Size Arrays

Time for array size n

Time vs array size

• Doubling the size of the array more

than doubles the time needed to sort it

Analyzing the Selection Sort Algorithm

• In an array of size n, count how many times an array element is visited o To find the smallest, visit n elements + 2 visits

for the swap

o To find the next smallest, visit (n-1) elements + 2 visits for the swap

o The last term is 2 elements visited to find the smallest + 2 visits for the swap

• The number of visits: o n + 2 + (n-1) + 2 + (n-2) +2 + . . .+ 2 + 2

o This can be simplified to n2 /2 + n/2 - 3

o n/2 - 3 is small compared to n2 /2 - so let's ignore it

o also ignore the 1/2 - it divides out when comparing ratios

• The number of visits is of the order n2

• Using big-Oh notation: The number of visits is O(n2)

• Multiplying the number of elements in an array by 2 multiplies the processing time by 4

Merge Sort

• Divide an array in half and sort each half

Merge Sort• Merge the two sorted arrays into a single

sorted array

Merge Sort

• Dramatically faster than the selection sort.

File MergeSorter.java 01: /**

02: This class sorts an array, using the merge sort

03: algorithm

04: */

05: public class MergeSorter

07: /**

08: Constructs a merge sorter.

09: @param anArray the array to sort

10: */

11: public MergeSorter(int[] anArray)

13: a = anArray;

16: /**

17: Sorts the array managed by this merge sorter

18: */

19: public void sort()

21: if (a.length <= 1) return;

22: int[] first = new int[a.length / 2];

23: int[] second = new int[a.length - first.length];

24: System.arraycopy(a, 0, first, 0, first.length);

25: System.arraycopy(a, first.length, second, 0, second.length);

26: MergeSorter firstSorter = new MergeSorter(first);

27: MergeSorter secondSorter = new MergeSorter(second);

28: firstSorter.sort();

29: secondSorter.sort();

30: merge(first, second);

33: /**

34: Merges two sorted arrays into the array to be sorted by this

35: merge sorter.

36: @param first the first sorted array

37: @param second the second sorted array

38: */

39: private void merge(int[] first, int[] second)

41: // merge both halves into the temporary array

43: int iFirst = 0;

44: // next element to consider in the first array

45: int iSecond = 0;

46: // next element to consider in the second array

47: int j = 0;

48: // next open position in a

50: // as long as neither i1 nor i2 past the end, move

51: // the smaller element into a

52: while (iFirst < first.length && iSecond < second.length)

54: if (first[iFirst] < second[iSecond])

56: a[j] = first[iFirst];

57: iFirst++;

59: else

61: a[j] = second[iSecond];

62: iSecond++;

64: j++;

67: // note that only one of the two while loops

68: // below is executed

70: // copy any remaining entries of the first array

71: System.arraycopy(first, iFirst, a, j, first.length - iFirst);

73: // copy any remaining entries of the second half

74: System.arraycopy(second, iSecond, a, j, second.length - iSecond);

File MergeSortTest.java01: /**

02: This program tests the merge sort algorithm by

03: sorting an array that is filled with random numbers.

04: */

05: public class MergeSortTest

11: MergeSorter sorter = new MergeSorter(a);

12: sorter.sort();

Merge Sort vs Selection Sort

Merge Sort Timing Vs Selection Sort

Merge sort – rectangles

Selection sort - circles

Analyzing Merge Sort Algorithm

• In an array of size n, count how many times an array element is visited

• Assume n is a power of 2: n = 2m

• Calculate the number of visits to create the two sub-arrays and then merge the two sorted arrays

• 3 visits to merge each element or 3n visits

• 2n visits to create the two sub-arrays

• total of 5n visits

• Let T(n) denote the number of visits to sort an array of n elements then

o T(n) = T(n/2) + T(n/2) + 5n or

o T(n) = 2*T(n/2) + 5n

• The visits for an array of size n/2 is T(n/2) = 2*T(n/4) + 5n/2 o So T(n) = 2 * 2*T(n/4) +5n + 5n

• The visits for an array of size n/4 is T(n/4) = 2*T(n/8) + 5n/4 o So T(n) = 2 * 2 * 2*T(n/8) + 5n + 5n + 5n

• Repeating the process k times: T(n) = 2kT(n/2k) +5nk

• since n = 2m, when k = m: T(n) = 2mT(n/2m) +5nm

• T(n) = nT(1) +5nm • T(n) = n + 5nlog2(n)

• To establish growth order

o Drop the lower-order term n

o Drop the constant factor 5

o Drop the base of the logarithm since all logarithms are related by a common factor

o We are left with n log(n)

• Using big-Oh notation: The number of visits is O( nlog(n) )

Merge Sort Vs Selection Sort

• Selection sort is an O( n2 ) algorithm

• Merge sort is an O( nlog(n) ) algorithm • The nlog(n) function grows much

more slowly than n2

Sorting in a Java Program

• The Arrays class contains static sort methods

• To sort an array of integers int[] intArray = . . . ;

Arrays.sort(intArray);

Linear Search

• Also called sequential search

• Examines all values in an array until it finds a match or reaches the end

• Number of visits for a linear search of an array of n elements:

o The average search visits n/2 elements

o The maximum visits is n

• A linear search is an O(n) algorithm

File LinearSearcher.java 01: /**

02: A class for executing linear searches through an array.

03: */

04: public class LinearSearcher

06: /**

07: Constructs the LinearSearcher.

08: @param anArray an array of integers

09: */

10: public LinearSearcher(int[] anArray)

12: a = anArray;

15: /**

16: Finds a value in an array, using the linear search

17: algorithm.

18: @param v the value to search

19: @return the index at which the value occurs, or -1

20: if it does not occur in the array

21: */

22: public int search(int v)

26: if (a[i] == v)

27: return i;

29: return -1;

File LinearSearchTest.java01: import javax.swing.JOptionPane;

03: /**

04: This program tests the linear search algorithm.

05: */

06: public class LinearSearchTest

14: LinearSearcher searcher = new LinearSearcher(a);

16: boolean done = false;

17: while (!done)

20: "Enter number to search for, Cancel to quit:");

21: if (input == null)

22: done = true;

23: else

26: int pos = searcher.search(n);

27: System.out.println("Found in position " + pos);

30: System.exit(0);

Binary Search

• Locates a value in a sorted array by

o Determining whether the value occurs in the first or second half

o Then repeating the search in one of the halves

Binary Search

• Count the number of visits to search an sorted array of size n

o We visit one element (the middle element) then search either the left or right subarray

o Thus: T(n) = T(n/2) + 1

Binary Search

• If n is n/2, then T(n/2) = T(n/4) + 1

• Substituting into the original equation: T(n) = T(n/4) + 2

• This generalizes to: T(n) = T(n/2k) + k

Binary Search

• Assume n is a power of 2, n = 2m

• Then: T(n) = T(n/2m) + m

• Since m = log2(n), then: T(n) = 1 + log2(n)

Binary Search

• Binary search is an O( log(n) ) algorithm

File BinarySearcher.java 01: /**

02: A class for executing binary searches through an array.

03: */

04: public class BinarySearcher

06: /**

07: Constructs a BinarySearcher.

08: @param anArray a sorted array of integers

09: */

10: public BinarySearcher(int[] anArray)

12: a = anArray;

15: /**

16: Finds a value in a sorted array, using the binary

17: search algorithm.

18: @param v the value to search

19: @return the index at which the value occurs, or -1

20: if it does not occur in the array

21: */

22: public int search(int v)

24: int low = 0;

25: int high = a.length - 1;

26: while (low <= high)

28: int mid = (low + high) / 2;

29: int diff = a[mid] - v;

31: if (diff == 0) // a[mid] == v

32: return mid;

33: else if (diff < 0) // a[mid] < v

34: low = mid + 1;

35: else

36: high = mid - 1;

38: return -1;

File BinarySearchTest.java 01: import java.util.Arrays;

02: import javax.swing.JOptionPane;

04: /**

05: This program tests the binary search algorithm.

06: */

07: public class BinarySearchTest

14: Arrays.sort(a);

16: BinarySearcher searcher = new BinarySearcher(a);

19: while (!done)

22: "Enter number to search for, Cancel to quit:");

24: done = true;

25: else

28: int pos = searcher.search(n);

29: System.out.println("Found in position " + pos);

32: System.exit(0);

Searching a Sorted Array in a Program

• The Arrays class contains a static binarySearch method

• The method returns either o The index of the element, if element is found

o Or -k - 1 where k is the position before which the element should be inserted

Searching a Sorted Array in a Program

• To search an integer array

int[] intArray = { 1, 4, 9 }; int v = 7; int pos = Arrays.binarySearch(intArray, v);

//returns -3; //v should be inserted before position 2

Sorting and Searching Arrays of Objects

• The Arrays class contain methods for searching or sorting collections of objects that implement the Comparable interface

• Comparable interface

public interface Comparable { int compareTo(Object otherObject);

• The call a.compareTo(b) o Returns a negative number is a should come

before b

o Returns 0 if a and b are the same

o Returns a positive number otherwise

CompareTo for BankAccount public class BankAccount

public int compareTo(Object otherObject)

BankAccount other = (BankAccount)otherObject;

if (balance < other.balance) return -1;

if (balance == other.balance return 0;

return 1;

CompareTo Method

• The implementation must define a total ordering relationship

o Antisymmetric

o Reflexive

o Transitive

CompareTo Method

• Antisymmetric: sign( x.compareTo(y) ) = -sign(y.compareTo(x) )

CompareTo Method

• Reflexive : x.compareTo(x) = 0

CompareTo Method

• Transitive :

If x.compareTo(y) <= 0 and y.compareTo(Z) <= 0, then x.compareTo(z) <= 0

Sorting and Searching Using Comparator

• The Arrays class contains a sort method that can sort array of objects that implement the Comparator interface

• The Comparator interface public interface Comparator {

– public int compare( Object firstObject, Object secondObject);

• If comp is a Comparator object, then the call comp.compare(a, b) o Returns a negative number if a should come

before b

o Returns 0 if a and b are the same o Returns a positive number otherwise

Comparator Class for Coins public class CoinComparator implements Comparator

public int compare(Object firstObject, Object secondObject)

Coin first = (Coin)firstObject;

Coin second = (Coin)secondObject;

if ( first.getValue() < second.getValue() )

return -1;

if ( first.getValue() == second.getValue() )

return 0;

return 1;

Sorting an Array of Objects

• Using a Comparator : Coin[] s = . . . ;

Comparator comp = new CoinComparator();

Arrays.sort(coinArray, comp);

Sorting and Searching ArrayLists

• The Collections class contains static sort and

binarySearch methods

• Given you have a Comparator object for that class of object

• These methods can be used to sort an ArrayList of object

Sorting an ArrayList of Objects

• Using a Comparator :

ArrayList Coins = new ArrayList();

//add coins

Comparator comp = new CoinComparator();

Collections.sort(coins, comp);

File Purse.java01: import java.util.ArrayList;

02: import java.util.Collections;

03: import java.util.Comparator;

05: /**

06: A purse holds a collection of coins.

07: */

08: public class Purse

10: /**

11: Constructs an empty purse.

12: */

13: public Purse()

15: coins = new ArrayList();

18: /**

19: Add a coin to the purse.

20: @param aCoin the coin to add

21: */

22: public void add(Coin aCoin)

24: coins.add(aCoin);

27: /**

28: Returns a string describing the purse contents,

29: sorted by coin value.

30: @return the string describing the purse contents

31: */

32: public String toString()

34: // sort the coins first

35: class CoinComparator implements Comparator

37: public int compare(Object firstObject, Object secondObject)

39: Coin first = (Coin)firstObject;

40: Coin second = (Coin)secondObject;

41: if (first.getValue() < second.getValue()) return -1;

42: if (first.getValue() == second.getValue()) return 0;

43: return 1;

47: Comparator comp = new CoinComparator();

48: Collections.sort(coins, comp);

50: String r = "Purse[coins=";

51: for (int i = 0; i < coins.size(); i++)

53: if (i > 0) r = r + ",";

54: r = r + coins.get(i);

56: return r + "]";

59: private ArrayList coins;

File PurseTest.java01: import javax.swing.JOptionPane;

03: /**

04: This class tests the Purse class by prompting the

05: user to add coins into a purse and printing the

06: purse contents, sorted by coin value.

07: */

08: public class PurseTest

12: double NICKEL_VALUE = 0.05;

13: double DIME_VALUE = 0.1;

14: double QUARTER_VALUE = 0.25;

16: Purse myPurse = new Purse();

19: while (!done)

21: String input

22: = JOptionPane.showInputDialog("Enter coin name or Cancel");

24: done = true;

25: else

27: double value = 0;

28: if (input.equals("nickel"))

29: value = NICKEL_VALUE;

30: else if (input.equals("dime"))

31: value = DIME_VALUE;

32: else if (input.equals("quarter"))

33: value = QUARTER_VALUE;

34: if (value != 0)

36: Coin c = new Coin(value, input);

37: myPurse.add(c);

38: System.out.println("The contents of the purse is "

39: + myPurse);

43: System.exit(0);

CHAPTER 18 SORTING AND SEARCHING. CHAPTER GOALS To study the several searching and sorting...

Documents