Last Updated: Saturday 2nd September 2017

## Prerequisites

To learn about Linear and Binary search, you'll need to have a good understanding of:

1. Python 3
2. Basic Python data structure concepts - lists

## Introduction

Often we will have to find an element from a given data structure like lists, linked lists or binary trees. An efficient searching technique saves a great amount of time and improves performance. In this tutorial, we are going to see two very commonly used searching algorithms.

### Linear Search

So if you were to search “Harry Potter”, from a shelf in a poorly lit room how would you go about it? You would start at one end, take one book at a time and check if it's Harry Potter or not. You will use a brute force methodology which checks every book until the Harry Potter is found or the end of the shelf is reached. Best case scenario would be when Harry Potter is the first book and worst case would be the book not in there at all. Either way, you can know this only by checking each and every book. This is exactly what Linear Search is.

### Binary Search

What if you were to search for Harry Potter from a shelf of books which are ordered alphabetically? Would you start searching from the start? Definitely not! You would start somewhere near the middle and check the first letter of the books and then go back or forward from there to find the 'H' titles. This means that you won’t be looking at all the books, thus saving time. You also won't need to go through the entire shelf to know whether the book is there or not. At a given point you are eliminating many books which you will never look at. Binary Search is similar to this.

NOTE: Linear Search can be done on both sorted and unsorted items but Binary Search can only be done on a sorted set of items.

## Implementation

Now that you know what Linear and Binary Search methodologies are, let us look at how these searches would work on a list of numbers.

#### Linear Search

Given list A = [6,3,9,0,5,8,2] find if 0 is present in this list or not.

#### Algorithm

1. Take one number at a time from list A
2. Compare it with 0 and check if it is a match:
1. If yes, return True
2. If not, return False
3. If the end of the list is met, return False

#### Code

```def linearSearch(ls,data):

for item in ls:
if item == data:
return True
return False```

print(linearSearch([6,3,9,5,8,2],0))

#### Binary Search

The idea is to keep comparing the element with the middle value. This way with each search we eliminate one half of the list.

#### Algorithm

1. Keep track of two pointers First and Last, these are incremented or decremented to limit the part of the list to be searched.
2. Find the middle element of the list: mid = ( length of the list )/2
3. Compare the middle element with the value to be found
4. Check if the middle element is lesser than the value to be found:
1. If yes, the element must lie on the second half of the list
2. If no, the element must lie on the first half of the list
5. Repeat steps 1 through 3 until the element is found or the end of the list is reached

NOTE: The list continues to get divided into two and the middle element gets compared until the element is found or no more elements are left to compare with.

Code

Given list B = [2,5,7,8,9,11,14,16] find if 14 is present in this list or not.

```def binarySearch(ls,data):
first = 0
last = len(ls)-1
done = False

while first<=last and not done:
mid = (first+last)//2
if ls[mid] == data:
done = True
else:
if ls[mid] > data:
last = last-1
else:
first = first+1
return done

print(binarySearch([2,5,7,8,9,11,14,16],4))```
 Round First Last Mid ls[mid] Result 1 0 7 3 8 8<14 2 4 7 5 11 11<14 3 6 7 6 14 14=14

NOTE: To find the mid element, “(first+last)//2” is used instead of “(first+last)/2”. This gives us whole numbers especially when the length of the list is odd. Try 9/2 and 9//2 in your Python IDLE to get a better understanding.

Try out this animation for a better understanding of both these search algorithms. Try to find the first element of the array. Which is faster?

## Conclusion

From the above explanation, it must be clear that Binary Search is consistently faster than Linear Search. If you are familiar with o(n) notation, Linear Search is o(n) and Binary Search is log(n)

You can perform Linear Searches on a sorted list as well with a small optimization. You can stop the search once the number to be found exceeds the element being compared to. For instance, you want to search for 12 from the list [2,4,5,13,16,19], once you reach 13 you can stop because there is no way that 12 is going to come after 13 in a sorted list.

In this tutorial, we have discussed only the iterative method of Binary Search. Try to implement the recursive approach on your own.  Also, learn about the uses of these searches and when to apply them. That’s all for this tutorial. Happy Pythoning!