Linear search and binary search are two common searching algorithms for 1D data structures like arrays. Linear search sequentially scans the entire array to find a match, taking O(n) time in the worst case. Binary search works by dividing the search space in half at each step, taking O(log n) time to find a match in a sorted array. The document provides pseudocode and examples comparing the two approaches.

1. Week 3c
Basic Searching Algorithms
DATASTRUCTURESANDALGORITHMS
INSTRUCTOR: SulamanAhmadNaz
1

2. Searching
■ Searching is the process of determining
whether or not a given value exists in a
data structure or a storage media.
■ We will discuss two searching methods on
1D (Linear) data structures:
– Linear search
– Binary search.
2

3. Linear Search
■ It is also called as Serial or Sequential
Search.
■ The linear (or sequential) search algorithm
on an array is:
– Sequentially scan the array, comparing each
array item with the searched value.
– If a match is found; return the index of the
matched element; otherwise return NULL.
■ Note: linear search can be applied to both
sorted and unsorted arrays.
3

4. Linear Search
■ Step through array of records, one at a
time.
■ Look for record with matching key.
■ Search stops when
– record with matching key is found
– or when search has examined all records
without success.
4

5. Linear Search
Linear Search ( Array A, KEY)
Step 1: Set i to L
Step 2: While i <= U do
Step 3: if A[i] = KEY then go to step 7
Step 4: Set i to i + 1
Step 5: End While
Step 6: Print “Element not found” & Exit
Step 7: Print “Element x Found at index i”
Step 8: Exit
5

6. Linear Search
procedure linear_search (Array, KEY)
For each item in the Array
If item == KEY
return the item's location
End If
End For
End procedure
6

7. Linear Search
Algorithm LinearSearch (Array A[L..U], KEY)
For i = L to U
If A[i] == KEY
return i
End If
End For
return NULL
7

8. Working
KEY=33
8

9. Working
KEY=33
9

10. Working
KEY=33
10

11. Working
KEY=33
11

12. Working
KEY=33
12

13. Working
KEY=33
13

14. Working
KEY=33
14

15. Working
KEY=33
15

16. Working
KEY=33
16
1 2 3 4 5 6 7 8 9 10
return 7

17. Analysis of Linear Search
Algorithm LinearSearch (Array A[L..U], KEY)
For i = L to U
If A[i] == KEY
return i
End If
End For
return NULL
17
If n is the size of the array,
S(n) = O(1)

18. Analysis of Linear Search
Algorithm LinearSearch (Array A[L..U], KEY)
For i = L to U
If A[i] == KEY
return i
End If
End For
return NULL
18
If n is the size of the array,
the loop will run not more
than “n” times.
In each iteration, it performs
some constant time operations.
T(n) = n.c = O(n)

19. Best Case
KEY=10
19
1 2 3 4 5 6 7 8 9 10
return 1
T(n)BestCase = O(1)

20. Worst Case - 1
KEY=44
20
1 2 3 4 5 6 7 8 9 10
return 10
T(n)WorstCase = O(n)

21. Worst Case - 2
KEY=100
21
1 2 3 4 5 6 7 8 9 10
return NULL
T(n)WorstCase = O(n)

22. Average Case
■ In the Average Case, the value can be somewhere in the
array.
■ Average Case Time Complexity is the average of Time
Complexities of all the possible inputs.
■ Suppose we have an array of n records.
■ If we search for the first record, then it requires 1
comparison; if the second, then 2 comparisons, and so on.
■ The average of all these searches is:
(1+2+3+4+5+6+7+8+9+…+n+n)/(n+1) = n/2+1 = O(n)22

23. Advantages of Linear Search
■ The linear search is simple.
■ It is easier to understand & implement.
■ It does not require the data to be stored in
any particular order.
23

24. Disadvantages of Linear Search
■ It has a very poor efficiency as it takes lots
of comparisons to find a particular record
in big files.
■ It fails in very large databases especially in
real-time systems.
24

25. Scenario 1
■ Suppose you’re searching for a person in
the phone book. His/Her name starts with
K.
■ You could start at the beginning and keep
flipping pages until you get to the Ks.
■ But you’re more likely to start at a page in
the middle, because you know the Ks are
going to be near the middle of the phone
book.
25

26. Scenario 2
■ Suppose you’re searching for a word in a
dictionary, and it starts with O.
■ Again, you’ll start near the middle.
26

27. Scenario 3
27
2.7 billion monthly active users
■ Suppose you log on to Facebook. When you do,
Facebook has to verify that you have an account
on the site.
■ So, it needs to search for your username in its
database.
■ Let your username is LARAIB – for instance -
Facebook could start from the As and search for
your name.
■ But it makes more sense for it to begin
somewhere in the middle.

28. Binary Search
■ All these cases use the same algorithm to solve the problem:
BINARY SEARCH.
28

29. Binary Search
■ Binary search is a searching algorithm.
■ Its input is a sorted list of elements.
■ If an element you’re looking for is in that list, binary search
returns the position where it’s located.
■ Otherwise, binary search returns NULL.
29

30. Comparison with Linear Search
■ I’m thinking of a number between 1 and 100.
■ You have to try to guess my number in the fewest tries
possible.
■ With every guess, I’ll tell you if your guess is too low, too
high, or correct.
30

31. Comparison with Linear Search
■ Suppose you start guessing like
this: 1, 2, 3, 4 ….
■ Here’s how it would go.
31

32. Comparison with Linear Search
■ Suppose you start guessing like this:
1, 2, 3, 4 ….
■ Here’s how it would go.
32

33. Comparison with Linear Search
■ This is the sequential search.
■ With each guess, you’re eliminating only one number.
■ If my number was 99, it could take you 99 guesses to get
there!
33

34. Comparison with Linear Search
■ Here’s a better technique.
■ Start with 50.
34

35. Comparison with Linear Search
■ You just eliminated half the numbers!
■ Now you know that 1–50 are all too low.
35

36. Comparison with Linear Search
■ Next guess: 75.
■ Too high, but again you cut down half the remaining
numbers!
■ With binary search, you guess the middle number and
eliminate half the remaining numbers every time.
36

37. Comparison with Linear Search
■ Next is 63 (halfway between 50 and 75).
37

38. Comparison with Linear Search
■ This is binary search.
■ Here’s how many numbers you can eliminate every time.
38

39. Comparison with Linear Search
■ Whatever number I’m thinking of, you can guess in a
maximum of
seven guesses—because you eliminate so many numbers with
every guess!
39

40. Comparison with Linear Search
■ Suppose you’re looking for a word in
the dictionary. The dictionary has
240,000 words.
■ In the worst case, how many steps do
you think each search will take?
40

41. Comparison with Linear Search
■ Simple search could take 240,000 steps if the word you’re
looking for is the very last one in the book.
■ With each step of binary search, you cut the number of
words in half until you’re left with only one word.
41

42. Working
KEY=31
42

43. Working
KEY=31
43

44. Working
KEY=31
44

45. Working
KEY=31
45

46. Working
KEY=31
46

47. Working
KEY=31
47
return 5

48. Binary Search (Iterative Version)
Algorithm BinarySearch (Array A[L..U], KEY)
While L<=U, do
mid = (L+U)/2
If A[mid] == KEY
return mid
ElseIf A[mid] < KEY
L = mid + 1
Else
U = mid - 1
End If
End While
return NULL
48

49. Binary Search (Recursive Version)
Algorithm BinSearch (Array A, KEY, U, L)
If L>U
return NULL
End If
mid = (L+U)/2
If A[mid] == KEY
return mid
ElseIf A[mid] < KEY
return BinSearch(A, KEY, mid + 1, U)
Else
return BinSearch(A, KEY, L, mid - 1)
End If
49

50. Binary Search – Side by Side
Algorithm BinarySearch (Array A[L..U], KEY)
While L<=U, do
mid = (L+U)/2
If A[mid] == KEY
return mid
ElseIf A[mid] < KEY
L = mid + 1
Else
U = mid - 1
End If
End While
return NULL
50
Algorithm BinSearch (Array A, KEY, U, L)
If L>U
return NULL
End If
mid = (L+U)/2
If A[mid] == KEY
return mid
ElseIf A[mid] < KEY
return BinSearch(A, KEY, mid + 1,
U)
Else
return BinSearch(A, KEY, L, mid -
1)

51. Time Complexity: Comparisons
51
Algorithm BinSearch (Array A, KEY, U, L)
If L>U
return NULL
End If
mid = (L+U)/2
If A[mid] == KEY
return mid
ElseIf A[mid] < KEY
return BinSearch(A, KEY, mid + 1,
U)
Else
return BinSearch(A, KEY, L, mid -
1)
C(n) = C( n/2 ) + c
C(1) = c
C(n) = C(n/2) + c
C(1) = c

52. 52
c
c
c
c
C(n)
C(n/2
)
C(n/22
)
C(n/23
)
C(n/2k) =
C(1)
c
For what value of 2k will C(n/2k) become
T(1).
n/2k=1  n=2k  k=log2n
C(n) = c(k+1)
= c(log2n+1)
= O(log2n)

53. Practice Questions
53

54. 54