1. Linear search sequentially checks each element of an array to find a target item. It adds the item to the end of the array and uses a counter to check each element until it finds a match. 2. Binary search works on a sorted array. It checks the middle element first, then searches either the left or right half depending on if the target is smaller or larger than the middle element. 3. The example demonstrates linear search finding the letter 'G' in an array and binary search locating the number 44 through a series of steps that narrow the search space.

1. LINEAR SEARCH
Presented By
Nikunj Patel
Parth Patel
DATA
STRUCTURE

2. Searching: Finding the location of
item or printing some message when
item is not found.
SEARC
H
LINEAR BINARY

3.  Linear search: Traversing data sequentially to locate
item is called linear search.
 Ex: Searching an item for operation in array.
 Binary search: Data in array which is sorted in
increasing numerical order or alphabetically.
 Ex: Searching name in telephone directory,
searching words in dictionary.

4. LINEAR SEARCH
 It test whether the ITEM in DATA is present or
not.
 It test the data in sequential manner.
 It searches the data one by one fully and returns
the ITEM as the result.
 Otherwise, it returns the value 0.
 We see this by ALGORITHM.

5. Alg:LINEAR(DATA,N,ITEM,LOC)
 Items explanation:
1. DATA --Linear array
2. N --Number of elements
3. ITEM --Elements to find
4. LOC --Location of the item

6. STEPS:
1. [Insert ITEM at the end] Set DATA[N+1]:=ITEM.
2. [Initialize counter] Set LOC:=1.
3. [Search for ITEM]
Repeat while DATA[LOC]= ITEM:
Set LOC:=LOC+1.
[End if loop]
4. [Successful?]If LOC:=N+1, then ;
Set LOC:=0
5. Exit

7. EXECUTION WITH EXAMPLE
PARTICULARS:
1. DATA [6] =
2. ITEM=G
Cell
name
A B C D E F
Loc 1 2 3 4 5 6

8.  To find the item we are first inserting the item to the
end of the list.
 Step 1: DATA[N+1]=ITEM.
Exp:
N=6
DATA[6]=F
DATA[6+1]=G
 So the item is added at LOC[7]
A B C D E F G
1 2 3 4 5 6 7

9.  Step 2:
Initializing the counter to start the search.
Therefore, LOC=1.
It starts the search from LOC=1{i.e. from
DATA[1]=A}
 Step 3:
WHILE loop is executed till DATA[LOC]=ITEM
From the step 2, LOC=1

10. A B C D E F G
A B C D E F G
A B C D E F G
A B C D E F G
S
E
A
R
C
H
I
N
G

11. A B C D E F G
S
E
A
R
C
H
I
N
G
A B C D E F G
A B C D E F G

12. Here the item is found
 The item ‘G’ is located
 So the loop executes until this condition
A B C D E F G

13.  STEP 4:
Originally the location is 6. We added the item at
the end.
So the item is located in 7.
LOC=N+1
We reached the condition then
LOC=0
 STEP 5:
Searching is finished and the algorithm exits.

14. Binary Search
• If the array is sorted, then we can apply the binary
search technique.
number
• The basic idea is straightforward. First search the
value in the middle position. If X is less than this
value, then search the middle of the left half next. If
X is greater than this value, then search the middle
of the right half next. Continue in this manner.
5 12 17 23 38 44 77
0 1 2 3 4 5 6 7 8
84 90

15. Sequence of Successful Search - 1
5 12 17 23 38 44 77
0 1 2 3 4 5 6 7 8
84 90
search( 44 )low high mid
0 8#1
highlow



 

2
highlow
mid
38 < 44 low = mid+1 = 5
mid
4

16. Sequence of Successful Search - 2
5 12 17 23 38 44 77
0 1 2 3 4 5 6 7 8
84 90
search( 44 )low high mid
0 8#1



 

2
highlow
mid
44 < 77high = mid-1=5
4
mid
6
highlow
5 8#2

17. Sequence of Successful Search - 3
5 12 17 23 38 44 77
0 1 2 3 4 5 6 7 8
84 90
search( 44 )low high mid
0 8#1



 

2
highlow
mid
44 == 44
4
5 8#2 6
highlow
5 5#3
mid
5
Successful Search!!

18. Sequence of Unsuccessful Search
- 4
5 12 17 23 38 44 77
0 1 2 3 4 5 6 7 8
84 90
search( 45 )low high mid
0 8#1



 

2
highlow
mid
4
5 8#2 6
5 5#3 5
high low
6 5#4
Unsuccessful Search
low > highno more elements to search

19. Binary Search Routine
public int binarySearch (int[] number, int searchValue) {
int low = 0,
high = number.length - 1,
mid = (low + high) / 2;
while (low <= high && number[mid] != searchValue) {
if (number[mid] < searchValue) {
low = mid + 1;
} else { //number[mid] > searchValue
high = mid - 1;
}
mid = (low + high) / 2; //integer division will
truncate
}
if (low > high) {
mid = NOT_FOUND;
}
return mid;
}