Searching

RHS – SOC 2 Searching A magic trick: –Let a person secretly choose a random number between 1 and 1000 –Announce that you can guess the number with only 10 attempts –The person must say ”higher” if the number is higher than your guess –The person must say ”lower” if the number is lower than your guess

RHS – SOC 3 Searching The magic trick obviously does not work, if the person does not ”direct” us How many guesses would we then typically need? If we increase the range to 1 up to 2000, how many more guesses will we need? –In the undirected case: 500 –In the directed case: 1

RHS – SOC 4 Searching Searching in sorted data is vastly easier than searching in unsorted data Consider an old-fashioned phone book –Given a name, find the number (easy) –Given a number, find the name (very hard) First search is Binary Search, second search is Linear Search

RHS – SOC 5 Searching Linear Search: –Given an unsorted array of data D containing n elements, check if the element e is in D –No shortcuts; got to check each element in D one by one –The time needed to do this is proportional to the size of D, i.e. proportional to n

RHS – SOC 6 Searching public boolean linearSearch(int e, int[] data, int n) { for (int i = 0; i < n; i++) { if (data[i] = e) return true; } return false; }

RHS – SOC 7 Searching Binary search: –Given a sorted array of data D containing n elements, check if the element e is in D –Let us be smarter now: Check the value in the middle of the array If the value is equal to e, we are done! If the value is larger than e, then start over with the first half of the array If the value is smaller than e, then start over with the second half of the array

RHS – SOC 8 Searching

RHS – SOC 9 Searching

RHS – SOC 10 Searching

RHS – SOC 11 Searching

RHS – SOC 12 Searching 3739 No match …

RHS – SOC 13 Searching Clearly, Binary Search is much faster than Linear Search… …but how fast is it? We can do an analysis of the so-called run- time complexity of the algorithm

RHS – SOC 14 Run-time complexity The run-time complexity gives us a measure of the expected running time of a specific algorithm Or rather, how the run- ning time is proportional to the ”size” of the input

RHS – SOC 15 Run-time complexity Example – Linear Search –Input is an array of length n –We will – on average – need to examine n/2 elements in the array –One examination of an element takes a constant amount of time –The complete running time is therefore proportional to n. –If n doubles, the running time doubles

RHS – SOC 16 Run-time complexity More formally, we could write the expected running time T(n) as T(n) = k 1 n + k 2 k 1 and k 2 are constants, which may be different for different hardware, program- ming language, and other factors We are usually only interested in the proportionality, not the exact running time

RHS – SOC 17 Run-time complexity For denoting the proportionality between the running time and the input size, we use the notation O(f(n)) meaning: the proportionality between the running time and the input size follows the function f(n)

RHS – SOC 18 Run-time complexity Examples: –O(log 2 (n))- very slow growth –O(n)- linear growth (Linear Search) –O(n 2 )- quadratic growth (fairly fast) –O(n 4 )- fast growth –O(2 n )- extremely fast growth

RHS – SOC 19 Run-time complexity n O(log 2 (n))12346 O(n) O(n 2 ) ,500 O(n 4 ) ,000160,0006 ×10 6 O(2 n )4321,0241 × ×10 15

RHS – SOC 20 Run-time complexity Given an algorithm, how do we then find the run-time complexity? We must examine the structure of loops in the algorithm, in particular nested loops We must examine the structure of method calls – very important in dealing with recursive algorithms Need to take library methods into account

RHS – SOC 21 Run-time complexity Example: Binary Search Input: Array of size n, element e to find Algorithm steps: –Until array has length 1, or e found Check value in middle of array If value is e; done – else run again with half of the array (which half depends on value)

RHS – SOC 22 Run-time complexity The time for doing Binary Search on n elements, is thus the sum of: –Doing a simple value comparison –Doing Binary Search on n/2 elements This can be written as: T(n) = 1 + T(n/2) This is a recursive function definition

RHS – SOC 23 Run-time complexity If T(n) = 1 + T(n/2) Then T(n) = 1 + (1 + T(n/4)) and generally T(n) = k + T(n/2 k ) Now write n = 2 k, and thus k = log 2 (n) Then T(n) = log 2 (n) + T(1) = O(log 2 (n))

RHS – SOC 24 Run-time complexity Since the run-time complexity of Binary Search is O(log 2 (n)), it is much faster than Linear Search If you need to search an array more than once, sort it first… …even though sorting does have a higher run-time complexity than Linear Search

RHS – SOC 25 Run-time complexity And that’s why the magic trick works: log 2 (1000) = 10

RHS – SOC 26 Exercises Review: R14.6 Programming: P14.8 Also try to program a recursive version of binary search