1 / 25

Searching – Linear and Binary Searches

Searching – Linear and Binary Searches. Comparing Algorithms. P1. P2. Should we use Program 1 or Program 2? Is Program 1 “fast”? “Fast enough”?. You and Igor: the empirical approach. Implement each candidate. Run it. Time it. That could be lots of work – also error-prone.

donnan
Télécharger la présentation

Searching – Linear and Binary Searches

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. Searching – Linear and Binary Searches

  2. Comparing Algorithms P1 P2 Should we use Program 1 or Program 2? Is Program 1 “fast”? “Fast enough”?

  3. You and Igor: the empirical approach Implement each candidate Run it Time it That could be lots of work – also error-prone. Which inputs? What machine/OS?

  4. Toward an analytic approach … How to solve “which algorithm” problems without machines, test data, or Igor!

  5. Input (n = 3) Input (n = 4) Input (n = 8) Output Output Output The Big Picture Algorithm How long does it take for the algorithm to finish?

  6. Primitives • Primitive operations • x = 4 assignment • ... x + 5 ... arithmetic • if (x < y) ... comparison • x[4] index an array • *x dereference (C) • x.foo( ) calling a method • Others • new/malloc memory usage

  7. N Σ j = 1 How many foos? for (j = 1; j <= N; ++j) { foo( ); } 1 = N

  8. N M Σ Σ j = 1 k = 1 How many foos? for (j = 1; j <= N; ++j) { for (k = 1; k <= M; ++k) { foo( ); } } 1 = NM

  9. N j N Σ Σ Σ j = 1 k = 1 j = 1 How many foos? for (j = 1; j <= N; ++j) { for (k = 1; k <= j; ++k) { foo( ); } } N (N + 1) 1 = j = 2

  10. How many foos? for (j = 0; j < N; ++j) { for (k = 0; k < j; ++k) { foo( ); } } for (j = 0; j < N; ++j) { for (k = 0; k < M; ++k) { foo( ); } } N(N + 1)/2 NM

  11. How many foos? T(0) = T(1) = T(2) = 1 T(n) = 1 + T(n/2) if n > 2 T(n) = 1 + (1 + T(n/4)) = 2 + T(n/4) = 2 + (1 + T(n/8)) = 3 + T(n/8) = 3 + (1 + T(n/16)) = 4 + T(n/16) … ≈ log2 n void foo(int N) { if(N <= 2) return; foo(N / 2); }

  12. What is Big-O? Big-O refers to the order of an algorithm runtime growth in relation to the number of items Focus on dominant terms and ignore less significant terms and constants as n grows SortingBigOh

  13. What is Big-O? Big-O refers to the order of an algorithm runtime growth in relation to the number of items I. O(l) - constant time (Push and pop elements on a stack) II. O(n) - linear time The algorithm requires a number of steps proportional to the size of the task. (Finding the minimum of a list) III. O(n2) - quadratic time The number of operations is proportional to the size of the task squared. (Selection and Insertion sort) IV. O(log n) - logarithmic time (Binary search on a sorted list) V. O(n log n) - "n log n " time (Merge sort and quicksort) SortingBigOh

  14. How would you find the first locker with a chinchilla in it?

  15. It’s the 6th one from the left

  16. Searching • 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: • The average search visits n/2 elements • The maximum visits is n • A linear search locates a value in an array in O(n) steps

  17. Pick a Number • Pick a number between 1 and 100. • You want to determine my number in the least amount of guesses possible. • How do you do it?

  18. Binary Search • Locates a value in a sorted array by • Determining whether the value occurs in the first or second half • Then repeating the search in one of the halves

  19. Binary Search 15 ≠ 17: we don't have a match

  20. Binary Search • Count the number of visits to search an sorted array of size n • We visit one element (the middle element) then search either the left or right subarray • Thus:     T(n) = T(n/2) + 1 where T(n) is time to search an array of size n • 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

  21. Binary Search • Assume n is a power of 2,    n = 2mwhere m = log2(n) • Then:    T(n) = 1 + log2(n) • Binary search is an O(log(n)) algorithm

  22. Comparison of Sequential and Binary Searches

  23. Assignment • Program a linear/sequential search of an array of Strings • Output the index where the element was found. Output must be user friendly • “Your value was found at index 13”; • “Your value was found at index -1” or “Your value was not found” • Program a binary search of an ArrayListof Integer • Recursive • “Your value was found in the array” or “Your value was not found in the array”

More Related