Chapter 15: Algorithms 1 ©2000, John Wiley & Sons, Inc. Horstmann/Java Essentials, 2/e 1 Chapter 15 Algorithms

©2000, John Wiley & Sons, Inc.Horstmann/Java Essentials, 2/e

1

Chapter 15: Algorithms1

Chapter 15Algorithms


2


Program SelSortTest.java

public class SelSortTest{ public static void main(String[] args) { int[] a = ArrayUtil.randomIntArray(20, 100);

ArrayUtil.print(a); SelSort.sort(a); ArrayUtil.print(a); }}


3


Class SelSort.java

public class SelSort /** Finds the smallest element in an array range.

@param a the array to search @param from the first position in a to compare @return the position of the smallest element in the range a[from]...a[a.length - 1]*/


4


{ public static int minimumPosition(int[] a, int from) { int minPos = from; for (int i = from + 1; i < a.length; i++) if (a[i] < a[minPos]) minPos = i; return minPos; } /** Sorts an array. @param a the array to sort */ public static void sort(int[] a) { for (int n = 0; n < a.length - 1; n++) { int minPos = minimumPosition(a, n); if (minPos != n) ArrayUtil.swap(a, minPos, n); } }}


5


Class ArrayUtil.java

import java.util.Random;

/** This class contains utility methods for array manipulation.*/

public class ArrayUtil{ /** Creates an array filled with random values. @param length the length of the array @param n the number of possible random values @return an array filled with length numbers between 0 and n-1 */ public static int[] randomIntArray(int length, int n) { int[] a = new int[length]; Random generator = new Random(); for (int i = 0; i < a.length; i++)


6


a[i] = generator.nextInt(n); return a; }

/** Swaps two elements in an array. @param a the array with the elements to swap @param i the index of one of the elements @param j the index of the other element */ public static void swap(int[] a, int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; }


7


/** Prints all elements in an array. @param a the array to print */ public static void print(int[] a) { for (int i = 0; i < a.length; i++) System.out.print(a[i] + ” "); System.out.println(); }}


8


Class StopWatch.java

/** A stopwatch accumulates time when it is running. You can repeatedly start and stop the stopwatch. You can use a stopwatch to measure the running time of a program.*/

public class StopWatch{ /** Constructs a stopwatch that is in the stopped state and has no time accumulated. */ public StopWatch() { reset(); }


9


/** Starts the stopwatch. Time starts accumulating now.*/public void start(){ if (isRunning) return; isRunning = true; startTime = System.currentTimeMillis();}

/** Stops the stopwatch. Time stops accumulating and is added to the elapsed time.*/

public void stop(){ if (!isRunning) return; isRunning = false; long endTime = System.currentTimeMillis(); elapsedTime = elapsedTime + endTime - startTime;}


10


/** Returns the total elapsed time. @return the total elapsed time*/public long getElapsedTime(){ if (isRunning) { long endTime = System.currentTimeMillis();

elapsedTime = elapsedTime + endTime - startTime; startTime = endTime;}return elapsedTime;}


11


/** Stops the watch and resets the elapsed time to 0. */ public void reset() { isRunning = false; elapsedTime = 0; }

private long elapsedTime; private long startTime; private boolean isRunning;}


12


Program SelSortTime.java

public class SelSortTime{ public static void main(String[] args) { ConsoleReader console = new ConsoleReader(System.in);

//construct random array

System.out.println("Enter array size: "); int n = console.readInt(); int[] a = ArrayUtil.randomIntArray(n, 100);


13


// use stopwatch to time selection sort

StopWatch timer = new StopWatch();

timer.start(); SelSort.sort(a); timer.stop();

System.out.println("Elapsed time: " + timer.getElapsedTime() + ” milliseconds"); }}


14


Figure 1Time Taken Selection bySort


15


Program MergeSortTest.java

public class MergeSortTest{ public static void main(String[] args)

{ int[] a = ArrayUtil.randomIntArray(20, 100); ArrayUtil.print(a); MergeSort.sort(a); ArrayUtil.print(a); }}


16


Class MergeSort.java

public class MergeSort{ /** Merges two adjacent subranges of an array @param a the array with entries to be merged @param from the index of the first element of the first range @param mid the index of the last element of the first range @param to the index of the last element of the second range */ public static void merge(int[] a, int from, int mid, int to) { int n = to - from + 1; // size of the range to be merged

// merge both halves into a temporary array b int[] b = new int[n];


17


int i1 = from; // next element to consider in the first rangeint i2 = mid + 1; // next element to consider in the second rangeint j = 0; // next open position in b

// as long as neither i1 nor i2 past the end, move// the smaller element into bwhile (i1 <= mid && i2 <= to){ if (a[i1] < a[i2]) { b[j] = a[i1]; i1++; } else { b[j] = a[i2]; i2++; }


18


j++;}// note that only one of the two while loops// below is executed

// copy any remaining entries of the first halfwhile (i1 <= mid){ b[j] = a[i1]; i1++; j++;}

// copy any remaining entries of the second halfwhile (i2 <= to){ b[j] = a[i2]; i2++; j++;}


19


/** Sorts a range of an array, using the merge sort algorithm. @param a the array to sort @param from the first index of the range to sort @param to the last index of the range to sort*/public static void MergeSort(int[] a, int from, int to){ if (from == to) return; int mid = (from + to) / 2; // sort the first and the second half mergeSort(a, from, mid); mergeSort(a, mid + 1, to); merge(a, from, mid, to);}

// copy back from the temporary array for (j = 0; j < n; j++) a[from + j] = b[j];}


20


/** Sorts an array, using the merge sort algorithm. @param a the array to sort */ public static void sort(int[] a) { mergeSort(a, 0, a.length - 1); }}


21


Figure 2Merge Sort Timing(Rectangles) versus SelectionSort (Circles)


22


Figure 3Babbage’s Difference Engine


23


Program LinearSearch.java

public class LinearSearch{ public static void main(String[] args) { ConsoleReader console = new ConsoleReader(System.in);

// construct random array

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

ArrayUtil.print(a); System.out.println("Enter number to search for:"); int n = console.readInt();

int j = search(a, n); System.out.println("Found in position ” + j); }


24


/** Finds a value in an array, using the linear search algorithm. @param a the array @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 static int search(int[] a, int v){ for (int i = 0; i < a.length; i++)


25


{ if (a[i] == v) return i; } return -1; }}


26


Program BinarySearch.java

public class BinarySearch{ public static void main(String[] args) { ConsoleReader console = new ConsoleReader(System.in);

// construct random array and sort it

int[] v = ArrayUtil.randomIntArray(20, 100); SelSort.sort(v);

ArrayUtil.print(v); System.out.println("Enter number to search for:"); int n = console.readInt();

int j = search(v, n);

System.out.println("Found in position ” + j); }


27


/** Finds a value in a range of a sorted array, using the binary search algorithm. @param a the sorted array @param from the first index in the range to search @param to the last index in the range to search @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 static int binarySearch(int[] a, int from, int to, int v){ if (from > to) return -1;


28


int mid = (from + to) / 2; int diff = a[mid] - v; if (diff == 0) // a[mid] == v return mid; else if (diff < 0) // a[mid] < v return binarySearch(a, mid + 1, to, v); else return binarySearch(a, from, mid - 1, v);}


29


/** Finds a value in a sorted array, using the binary search algorithm. @param a the sorted array @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 static int search(int[] a, int v) { return binarySearch(a, 0, a.length -1, v); }}


30


Program FibTime.java

public class FibTime{ public static void main(String[] args) { ConsoleReader console = new ConsoleReader(System.in); System.out.println("Enter n: "); int n = console.readInt();

// use stopwatch to time Fibonacci number computation


timer.start(); int f = fib(n); timer.stop();

System.out.println("fib(“ + n + ")= ” + f); System.out.println("Elapsed time = " + timer.getElapsedTime() + “ milliseconds");}


31


/** Computes a Fibonacci number. @param n an integer @return the nth Fibonacci number */ public static int fib(int n) { if (n <= 2) return 1; else return fib(n - 1) + fib(n - 2); }}


32


Program FibTrace.java

public class FibTrace{ public static void main(String[] args) { ConsoleReader console = new ConsoleReader(System.in); System.out.println("Enter n:"); int n = console.readInt();

int f = fib(n);

System.out.println("fib(” + n + ") = ” + f); }


33


/** Computes a Fibonacci number. @param n an integer @return the nth Fibonacci number */ public static int fib(int n) { System.out.println("Entering fib: n = ” + n); int f; if (n <= 2) f = 1; else f = fib(n - 1) + fib(n - 2); System.out.println("Exiting fib: n = ” + n + ” return value = ” + f); return f; }}


34


Program FibLoop.java

public class FibLoop{ public static void main(String[] args) { ConsoleReader console = new ConsoleReader(System.in); System.out.println("Enter n: ");


35


int n = console.readInt();

// use stopwatch to time Fibonacci number computation


timer.start(); int f = fib(n); timer.stop();

System.out.println("fib(” + n + ") = ” + f); System.out.println("Elapsed time = " + timer.getElapsedTime() + ” milliseconds");}


36


/** Computes a Fibonacci number. @param n an integer @return the nth Fibonacci number */ public static int fib(int n) { if (n <= 2) return 1; int fold = 1; int fold2 = 1; int fnew = 1; for (int i = 3; i <= n; i++) { fnew = fold + fold2; fold2 = fold; fold = fnew; } return fnew; }}


37


Figure 4Graphical Animation

Documents

Chapter 15: Algorithms 1 ©2000, John Wiley & Sons, Inc. Horstmann/Java Essentials, 2/e 1 Chapter 15 Algorithms