1 / 51

241-423 Advanced Data Structures and Algorithms

241-423 Advanced Data Structures and Algorithms. Objective introduce algorithm design using basic searching and sorting, and remind students about T() and Big-Oh running time. Semester 2, 2013-2014. 1 . Intro. to Algorithms. Contents. 1. Selection Sort 2. An Array Sublist

morag
Download Presentation

241-423 Advanced Data Structures and Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. 241-423 Advanced Data Structures and Algorithms Objective introduce algorithm design using basic searching and sorting, and remind students about T() and Big-Oh running time. Semester 2, 2013-2014 1. Intro. to Algorithms

  2. Contents 1. Selection Sort 2. An Array Sublist 3. Sequential Search 4. Binary Search 5. System/Memory Efficiency 6. Running Time Analysis 7. Big-Oh Analysis 8. The Timing Class

  3. 1. Selection Sort • Go through an array position by position, starting at index 0. • At the current position, select the smallest element from the rest of the array. • Swap it with the value in the current position.

  4. An Example

  5. Number of passes = size of array – 1 • e.g. made 4 passes over the 5-element arr[] • stopped sorting when finshed comparing arr[3] and arr[4]

  6. public static void selectionSort(int[] arr) { // index of smallest elem in sublist int smallIndex; int idx; int n = arr.length; // idx has range 0 to n-2 for (idx = 0; idx < n-1; idx++) { // scan sublist starting at idx smallIndex = idx; : selectionSort()

  7. /* j goes through sublist from arr[idx+1] to arr[n-1] */ for (int j = idx+1; j < n; j++) /* if smaller element found, assign smallIndex to that posn */ if (arr[j] < arr[smallIndex]) smallIndex = j; //* swap next smallest elem into arr[idx] int temp = arr[idx]; arr[idx] = arr[smallIndex]; arr[smallIndex] = temp; } } // end of selectionSort()

  8. Usage Example // an integer array int[] arr = {66, 20, 33, 55, 53, 57, 69, 11, 67, 70}; // use selectionSort() to order array selectionSort(arr); System.out.print("Sorted: "); for (int i=0; i < arr.length; i++) System.out.print(arr[i] + " "); Sorted: 11 20 33 53 55 57 66 67 69 70

  9. 2. An Array Sublist • An array sublist is a sequence of elements whose indices begin at index first and go up to, but not including, last. • Uses the notation: [first, last).

  10. 3. Sequential Search • Begin with a target value and index range [first, last). • Go through sublist item by item, looking for target. • Return the index position of the match or -1 if target is not in sublist.

  11. Examples

  12. seqSearch() public static int seqSearch(int[] arr, int first, int last, int target) { /* scan first <= i < last; return index for position if a match occurs */ for (int i = first; i < last; i++) if (arr[i] == target) return i; return -1; // target not found }

  13. 4. Binary Search • Binary search requires an ordered list, so large sections of the list can be skipped during the search. • Calculate midpoint of the current sublist [first,last). • If target matches midpoint value, then the search is finished. continued

  14. If target is less than midpoint value, look in the lower sublist; otherwise, look in the upper sublist. • Continue until target is found or sublist size is 0.

  15. Binary Search Case 1 • target == midpoint value. • The search is complete • mid is the index of the midpoint value

  16. Binary Search Case 2 • target < midValue • so search in lower sublist • Index range becomes [first, mid). • Set index last to be end of lower sublist (last = mid).

  17. Binary Search Case 3 • target > midValue • so search upper sublist • Index range becomes [mid+1,last), because the upper sublist starts to the right of mid • Set index first to be front of the upper sublist (first = mid+1).

  18. Binary Search Finish • The binary search stops when a match is found, or when the sublist is 'empty'. • an empty sublist for [first,last) is when first >= last.

  19. A Successful Search: Step 1 target = 23 continued

  20. Step 2 target = 23 The sublist is roughly halved. continued

  21. Step 3 target = 23 The sublist is roughly halved. continued

  22. Failure Example Step 1 target = 4 continued

  23. Step 2 target = 4 The sublist is roughly halved. continued

  24. Step 3 target = 4 The sublist is roughly halved. continued

  25. Step 4 Index range [2,2). first ≥ last, so search fails. The return value is -1.

  26. binSearch() public static int binSearch(int arr[], int first, int last, int target) { int mid; // index of midpoint int midValue; // value from arr[mid] // test for nonempty sublist while (first < last) { mid = (first+last)/2; midValue = arr[mid]; :

  27. if (target == midValue) return mid; // have a match // determine which sublist to search else if (target < midValue) // search lower sublist; set last last = mid; else // search upper sublist; set first first = mid+1; } return -1; // target not found } // end of binSearch()

  28. 5. System/Memory Efficiency • System efficiency is how fast an algorithm runs on a particular machine. • Memory efficiency is the amount of memory an algorithm uses • if an algorithm uses too much memory, it can be too slow, or may not execute at all, on a particular system.

  29. 6. Running Time Analysis • Machine-independent algorithm efficiency is measured in terms of the number of operations used in the code. • The complexity of the algorithm usually depends on some size measure • usually the size of the input data

  30. input data is the array, arr[] min() public static int min(int[] arr) // return the smallest elem. in arr[] { int n = arr.length; if (n == 0) { System.out.println("Array has 0 size"); return 0; } else { int min = arr[0]; for (int i = 1; i < n; i++) if (arr[i] < min) min = arr[i]; return min; } }

  31. Running Time Could count all operations, but T() would still be linear in n. • The number of comparison operations, T(n), required to find the smallest element in an n-element array. T(n) = n-1 T() was explained in241-303 "Discrete Maths",part 4

  32. Running Time: Selection Sort • Count the number of comparison operations used to sort an array of size n • there are n-1 passes altogether • in the first pass there are n-1 comparisons • in the 2nd pass, n-2 comparisons, ... T(n) = (n-1) + (n-2) + ... + 2 + 1 = n(n-1)/2 = n2/2 - n/2

  33. Running Time: seqSearch() • Best case: Find target at index 0. T(n) = 1 • Worst case: Find target at index n-1 or not finding it. T(n) = n • Average case: Average of the number of comparisons to find a target at any position. T(n) = (1+2+3...+n)/n = n(n+1)/2 * (1/n) = (n+1)/2

  34. Running Time: binSearch() • Best case: Target found at first midpoint. T(n) = 1 • Worst case: Length of sublists halves at each iteration. T(n) = (int) log2n + 1 • Average case: A fancy analysis shows: T(n) = (int) log2n

  35. 7. Big-Oh Notation • Big-Oh, O(n) is a simpler version of T(n) that only uses the 'biggest' term of the T(n) equation, without constants. • e.g. if T(n) = 8n3+5n2-11n+1, then T(n) is O(n3). • Selection sort is O(n2). • The average case for seqSearch() is O(n). • The worst case for binSearch() is O(log2n). O() was explained in241-303 "Discrete Maths",part 4

  36. Common Big-Oh's • Constant time: T(n) is O(1) when its running time is independent of the n value. • e.g. find the smallest value in an orderedn-element array continued

  37. Linear: T(n) is O(n) when running time is proportional to n, the size of the data. If n doubles, T() doubles. • e.g. find the smallest value in an unorderedn-element array, as in min() continued

  38. Quadratic: T(n) is O(n2). If n doubles, T() increases by a factor of 4 • e.g. selection sort • Cubic: T(n) is O(n3). Doubling n increases T() by a factor of 8 • e.g. multiplication of two n*n matricies continued

  39. Logarithmic: T() is O(log2n) or O(n log2n). • occurs when the algorithm repeatedly subdivides the data into sublists whose sizes are 1/2, 1/4, 1/8, ... of the original size n • e.g. binary search is O(log2n) • e.g. quicksort is O(n log2n) continued

  40. Exponential: T(n) is O(an). • These algorithms deal with problems that require searching through a large number of potential solutions before finding an answer. • e.g. the traveling salesman problem • mentioned in the Discrete Maths subject

  41. T() Graphs

  42. T() Equations

  43. A class in the Ford&Toppds.time package. 8. The Timing Class

  44. Timing Class Example Timing sortTimer = new Timing(); sortTimer.start(); // start timing selectionSort(arr); // sort double timeInSec = sortTimer.stop(); // get sorting time in secs

  45. Search Time Comparison • Compare sequential and binary search on the folllowing problem: target list 103 51 27 10 . . . . . . . 99 0 1 2 3 49,999 search for each inside ... listSeq (listBin after sorting) . . . . . . . 51 34 22 82 56 0 1 2 3 99,999

  46. SearchTimes import java.util.Random; import java.text.DecimalFormat; import ds.util.Arrays; // Ford & Topp packages import ds.time.Timing; public class SearchTimes { public static void main(String[] args) { int ARRAY_SIZE = 100000; int TARGET_SIZE = 50000; // arrays for searches int[] listSeq = new int[ARRAY_SIZE], listBin = new int[ARRAY_SIZE], targetList = new int[TARGET_SIZE]; :

  47. // use Timing object t to compute times Timing t = new Timing(); // random number object Random rnd = new Random(); // format real numbers with 3 dps DecimalFormat fmt = new DecimalFormat("#.000"); :

  48. // initialize arrays with random numbers for (int i = 0; i < ARRAY_SIZE; i++) listSeq[i]=listBin[i]= rnd.nextInt(1000000); // initialize targetList with random numbers for (int i=0; i < TARGET_SIZE; i++) targetList[i] = rnd.nextInt(1000000); // time seq. search for targets in listSeq t.start(); for (int i = 0; i < TARGET_SIZE; i++) Arrays.seqSearch(listSeq, 0, ARRAY_SIZE, targetList[i]); :

  49. double seqTime = t.stop(); System.out.println("Sequential Search takes " + fmt.format(seqTime) + " seconds."); // sort listBin Arrays.selectionSort(listBin); // time binary search for targets in listBin t.start(); for (int i = 0; i < TARGET_SIZE; i++) Arrays.binSearch(listBin, 0, ARRAY_SIZE, targetList[i]); :

  50. double binTime = t.stop(); System.out.println("Binary Search takes " + fmt.format(binTime) + " seconds."); System.out.println("Ratio of sequential to binary search time is " + fmt.format(seqTime/binTime)); } // end of main() } // end of SearchTimes class

More Related