Algorithms Lecture 6: Searching Algorithms

Analysis and Design of Algorithms
Searching Algorithms

Introduction
Linear Search
Binary Search
Jump Search
Interpolation Search

 Searching Algorithm is an algorithm made up of a series of
instructions that retrieves information stored within some data
structure, or calculated in the search space of a problem domain.
 There are many sorting algorithms, such as:
 Linear Search, Binary Search, Jump Search,
Interpolation Search, Exponential Search, Ternary
Search

Linear Search

 Linear Search is a method for finding a target value
within a list. It sequentially checks each element of
the list for the target value until a match is found or
until all the elements have been searched.

 Algorithm:
 Step1: Start from the leftmost element of array and one by one
compare x with each element of array.
 Step2: If x matches with an element, return the index.
 Step3: If x doesn’t match with any of elements, return -1.

 Assume the following Array:
 Search for 9
8 12 5 9 2

 Compare
 X=
8 12 5 9 2
9

i

 Found at index = 3
8 12 5 9 2

 Python Code

 Time Complexity: O(n)
 Example of worst case: search for the last element
4 6 8 9 1

Binary Search

Binary Search is the most popular Search algorithm.
It is efficient and also one of the most commonly
used techniques that is used to solve problems.
Binary search use sorted array by repeatedly
dividing the search interval in half.

 Algorithm:
 Step1: Compare x with the middle element.
 Step2: If x matches with middle element, we return the mid index.
 Step3: Else If x is greater than the mid element, search on right half.
 Step4: Else If x is smaller than the mid element. search on left half.

 Assume the following Array:
 Search for 40
2 3 10 30 40 50 70

 Compare
 X =
2 3 10 30 40 50 70

L

R

mid
40

 x=40 , found at index = 4
2 3 10 30 40 50 70

 Iterative python implementation:

 Recursive Python implementation:

 Time Complexity: O(log2 n)

Jump Search

Jump Search is a searching algorithm for sorted
arrays. The basic idea is to check fewer elements
(than linear search) by jumping ahead by fixed steps
or skipping some elements in place of searching all
elements.

 Algorithm:
 Step1: Calculate Jump size
 Step2: Jump from index i to index i+jump
 Step3: If x = = arr[i+jump] return x
 Else jump back a step
 Step4: Perform linear search

 Assume the following sorted array:
 Search for 77
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110

 Calculate:
• Size of array n =16
• Jump size = sqrt(n)= 4
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110

 Jump size = 4
 Search from index 0
 Compare index value with search number 0<77
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110
77

 Jump size = 4
 Jump from index 0 to index 3
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110
77

 Jump size = 4
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110
77

 Jump size = 4
 Compare index value with search number 89>77
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110
77

 jump back a step
 Perform linear search
 Compare found at index 11
0 1 1 2 3 5 8 13 21 34 55 77 89 91 95 110
77

 Time Complexity: O(sqrt(n))

Interpolation Search

The Interpolation Search is an improvement over Binary
Search for instances. On the other hand interpolation
search may go to different locations according the value of
key being searched.

 Algorithm:
 Step1: In a loop, calculate the value of “pos” using the position formula.
 Step2: If it is a match, return the index of the item, and exit.
 Step3: If the item is less than arr[pos], calculate the position of the left
sub-array. Otherwise calculate the same in the right sub-array.
 Step4: Repeat until a match is found or the sub-array reduces to zero.

// The idea of formula is to return higher value of pos
// when element to be searched is closer to arr[hi]. And
// smaller value when closer to arr[lo]
pos = lo + [ (x-arr[lo])*(hi-lo) / (arr[hi]-arr[Lo]) ]
arr[] ==> Array where elements need to be searched
x ==> Element to be searched
lo ==> Starting index in arr[]
hi ==> Ending index in arr[]

10 12 13 16 18 19 20 21 22 23 24 33 35 42 47

 Assume the following sorted array:
 Search for x= 18
10 12 13 16 18 19 20 21 22 23 24 33 35 42 47

 Calculate pos = lo + [ (x-arr[lo])*(hi-lo) / (arr[hi]-arr[Lo]) ]
 Lo=0, hi=14, arr[lo]=10, arr[hi]= 47
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
10 12 13 16 18 19 20 21 22 23 24 33 35 42 47

 Calculate pos = 3
 Compare with x=18
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
10 12 13 16 18 19 20 21 22 23 24 33 35 42 47

 Calculate pos = lo + [ (x-arr[lo])*(hi-lo) / (arr[hi]-arr[Lo]) ]
 Lo=4, hi=14, arr[lo]=18, arr[hi]= 47
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
10 12 13 16 18 19 20 21 22 23 24 33 35 42 47

 Calculate pos = 4
 Compare with x=18 , found at index 4
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
10 12 13 16 18 19 20 21 22 23 24 33 35 42 47

 Time Complexity: If elements are uniformly distributed, then O (log
log n)). In worst case it can take up to O(n).

facebook.com/mloey
mohamedloey@gmail.com
twitter.com/mloey
linkedin.com/in/mloey
mloey@fci.bu.edu.eg
mloey.github.io

Algorithms Lecture 6: Searching Algorithms

More Related Content

What's hot (20)

Similar to Algorithms Lecture 6: Searching Algorithms (20)

More from Mohamed Loey (20)

Recently uploaded (20)

Algorithms Lecture 6: Searching Algorithms