Searching

• We have seen that membership in lists can be checked using the following:

if x in list:

• How does Python do this?
• Given a list of integers, how can you search through the values to find one you are looking for?

Linear Search

• Going through a list item by item to find the value you are looking for is called linear search.
• How would you program this in Python?

# linearSearch() searches for the item in myList and returns
# the index of item in the list myList, or -1 if not found.
# Inputs: item, the item to search for
#         myList, the list to search for item
# Output: the index where item was found or -1 if index was 
#         not in the list  
def linearSearch(item, myList):

    for index in range(len(myList)):
        if myList[index] == item:
            return index

    return -1

Analysis

• How can we analyze the efficiency of linear search?
• The easiest metric to use is the number of operations required to find the item you are looking for.
• An operation, for our purposes, is any arithmetic or boolean operation (i.e. checking for equality)
• To make things a little easier, we will only consider the number of operations required in the worst case.

Linear Search Analysis

• What is the worst case for linear search?

• When the item you are searching for is the last item in the list (or not in the list), all other items have to be searched before you find it. It is literally "the last place you looked."
• In this case it takes six operations to find the the item you are looking for in the worst case.

Analysis Metric

• Since the worst case is always when the item you are searching for is the last item in the list, the number of operations required in this case is equal to the length of the list.
• A better way to say this is given a list of length n, we require n operations to find an element in it, in the worst case.
• As n grows, the amount of work required grows linearly, so this is known as a linear time algorithm.

Improving Search

• If the list is sorted, there is a faster method to search for a specific value called binary search.
• Think of how you would play the following game:
  • One player thinks of a number between 1 and 100.
  • The second player repeatedly guesses a number and the first player tells him/her whether the guess is too high, too low or correct.
• The best way to play this is to always guess halfway between the boundaries you know the answer to be in.
  • 50? Lower
  • 25? Lower
  • 12? Higher
  • 18? Higher
  • 21? Higher
  • 23? Lower
  • 22? Yes

Binary Search

• Now we can take this idea and translate it into a list searching problem.
• The key idea is to use two variables, called low and high, to keep track of the viable positions within the list where the sought after item can be found.

For example, suppose we were trying to find the word "strawberry".

• Let's go to the word that's right in the middle of the sorted list.
  low = 0, high = 7,
  mid = (7 + 0) / 2 => 3.
• "strawberry" comes after "cherry" in the dictionary, so we don't need to consider any words before "cherry" in the list.
  low = mid + 1 => 4, high = 7,
  mid = (4 + 7) / 2 => 5.
• "strawberry" comes after "mango", so we don't need to consider any words before it in the list.
  low = mid + 1 => 6, high = 7,
  mid = (6 + 7) / 2 => 6
• "strawberry" comes after "orange".
  low = mid + 1 => 7, high = 7,
  mid = (7 + 7) / 2 => 7
• "strawberry" comes after "pineapple".
  low = mid + 1 => 8, high = 7,
  as soon as low > high stop, not found

Another example, finding "banana".

• Start with the middle.
  low = 0, high = 7,
  mid = (0 + 7) / 2 => 3.
• "banana" comes before "cherry".
  low = 0, high = mid - 1 => 2,
  mid = (0 + 2) / 2 => 1
• "banana" comes after "avocado".
  low = mid + 1 => 2, high = 2,
  mid = (2 + 2) / 2 => 2
• "banana" is in the position we are looking at so we are done

Binary Search Code

• Seeing how binary search is done, how would you code it in Python?

# binarySearch() performs a binary search for an item in a list
# Inputs: list, the list to search
#         item, the item to search for
# Output: the index of item in the list, or -1 if not found
def binarySearch(list, item):

    low = 0
    high = len(list) - 1

    while low <= high:

        mid = (low + high) / 2


        # if found return the index
        if item == list[mid]:
            return mid

        # if item is in the 2nd half of the list
        elif item > list[mid]:
            low = mid + 1

        # if item is in the 1st half of the list
        else:
            high = mid - 1

    # item was not in list
    return -1

Analysis of Binary Search

• How much work does binarySearch do?

How fast is log₂(n) ?

How many accesses will it take to find X as we increase N ?

Keep in mind that a linear search of a list containing 1,000,000 items would require 1,000,000 accesses in the worst case.

So binary search which runs in log₂(n) is amazingly fast!