This document discusses linear search and binary search algorithms. Linear search sequentially checks each element of an unsorted array to find a target value, resulting in O(n) time complexity. Binary search works on a sorted array, comparing the target to the middle element and recursively searching half the array, requiring O(log n) time. The document provides pseudocode for both algorithms and compares their performance on different sized inputs. It also discusses properties of greedy algorithms and provides an example of when a greedy solution fails to find the optimal result.

1. Linear Search
&
Binary Search

2. Abdul Kahir
&
Abdul Mohaimin Rahat

3. What is algorithm and Algorithm design?
• An Algorithm is a Step by Step solution of a specific
mathematical or computer related problem.
• Algorithm design is a specific method to create a
mathematical process in solving problems.

4. Sorted Array
• Sorted array is an array where each element is sorted in
numerical, alphabetical, or some other order, and placed at
equally spaced addresses in computer memory.
1 2 3 4
0.2 0.3 1 1.5

5. Unsorted Array
• Unsorted array is an array where each element is
not sorted in numerical, alphabetical, or some other order,
and placed at equally spaced addresses in computer memory.
1 2 3 4
0.2 0.3 1.5 1

6. What is searching?
• In computer science, searching is the process of finding an item with
specified properties from a collection of items.The items may be stored as
records in a database, simple data elements in arrays, text in files, nodes in
trees, vertices and edges in graphs, or maybe be elements in other search
place.
• The definition of a search is the process of looking for something or
someone
• Example : An example of a search is a quest to find a missing person

7. Why do we need searching?
Searching is one of the core computer science algorithms. We know that today’s
computers store a lot of information.To retrieve this information proficiently we need
very efficient searching algorithms.
Types of Searching
• Linear search
• Binary search

8. Linear Search
• The linear search is a sequential search, which uses a loop to step
through an array, starting with the first element.
• It compares each element with the value being searched for, and
stops when either the value is found or the end of the array is
encountered.
• If the value being searched is not in the array, the algorithm will
unsuccessfully search to the end of the array.

9. Linear Search
• Since the array elements are stored in linear order searching the
element in the linear order make it easy and efficient.
• The search may be successful or unsuccessfully.That is, if the
required element is found them the search is successful other wise
it is unsuccessfully.

10. Unordered linear/ Sequential search
int unorderedlinearsearch (int A[], int n, int data)
{
for (int i=0; i<n; i++)
{
if(A[i] == data)
return i;
}
return -1;
}

11. Advantages of Linear search
• If the first number in the directory is the number you
were searching for ,then lucky you!!.
• ●Since you have found it on the very first page,now its
not important for you that how many pages are there in
the directory.
• The linear search is simple - It is very easy to
understand and implement
• It does not require the data in the array to be stored in
any particular order
• ●So it does not depends on no. on elements in the
directory.Hence constant time .

12. Disadvantages of Linear search
• It may happen that the number you are searching for is the last number of
directory or if it is not in the directory at all.
• In that case you have to search the whole directory.
• Now number of elements will matter to you.if there are 500 pages ,you have to
search 500;if it has 1000 you have to search 1000.
• Your search time is proportional to number of elements in the directory.
• It has very poor efficiency because it takes lots of comparisons to find a
particular record in big files
• The performance of the algorithm scales linearly with the size of the input
• Linear search is slower then other searching algorithms

13. Analysis of Linear Search
How long will our search take?
In the best case, the target value is in the first element of the array.
So the search takes some tiny, and constant, amount of time.
In the worst case, the target value is in the last element of the array.
So the search takes an amount of time proportional to the length of
the array.

14. Analysis of Linear Search
In the average case, the target value is somewhere in the array.
In fact, since the target value can be anywhere in the array, any element
of the array is equally likely.
So on average, the target value will be in the middle of the array.
So the search takes an amount of time proportional to half the length
of the array
The worst case complexity is O(n), sometimes known an O(n) search
Time taken to search elements keep increasing as the number of
elements are increased.

15. Abdul Kahir
161-15-7173

16. Binary Search
The general term for a smart search through sorted data is a binary search.
1. The initial search region is the whole array.
2. Look at the data value in the middle of the search region.
3. If you’ve found your target, stop.
4. If your target is less than the middle data value, the new search region
is the lower half of the data.
5. If your target is greater than the middle data value, the new search
region is the higher half of the data.
6. Continue from Step 2.

17. 17
Binary Search

18. © Reem Al-Attas
Binary Search
2. Calculate middle = (low + high) / 2.
= (0 + 8) / 2 = 4.
If 37 == array[middle]  return middle
Else if 37 < array[middle]  high = middle -1
Else if 37 > array[middle]  low = middle +1

19. 7/25/2017 © Reem Al-Attas 19
Binary Search
Repeat 2. Calculate middle = (low + high) / 2.
= (0 + 3) / 2 = 1.
If 37 == array[middle]  return middle
Else if 37 < array[middle]  high = middle -1
Else if 37 > array[middle]  low = middle +1

20. 7/25/2017 © Reem Al-Attas 20
Binary Search
Repeat 2. Calculate middle = (low + high) / 2.
= (2 + 3) / 2 = 2.
If 37 == array[middle]  return middle
Else if 37 < array[middle]  high = middle -1
Else if 37 > array[middle]  low = middle +1

21. ©The McGraw-Hill Companies, Inc. Permission required for reproduction or
display.
Chapter 11 - 21
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;
}

22. Binary Search Performance
• Successful Search
– Best Case – 1 comparison
– Worst Case – log2N comparisons
• Unsuccessful Search
– Best Case =
Worst Case – log2N comparisons
• Since the portion of an array to search is cut into half after every
comparison, we compute how many times the array can be
divided into halves.
• After K comparisons, there will be N/2K elements in the list. We
solve for K when N/2K = 1, deriving K = log2N.

23. Comparing N and log2N Performance
Array Size Linear – N Binary – log2N
10 10 4
50 50 6
100 100 7
500 500 9
1000 1000 10
2000 2000 11
3000 3000 12
4000 4000 12
5000 5000 13
6000 6000 13
7000 7000 13
8000 8000 13
9000 9000 14
10000 10000 14

24. Important Differences:
Input data needs to be sorted in Binary Search and not in Linear
Search
Linear search does the sequential access whereas Binary search
access data randomly.
Time complexity of linear search -O(n) , Binary search has time
complexity O(log n).
Linear search performs equality comparisons and Binary search
performs ordering comparisons

25. Greedy Algorithm
• A greedy algorithm is an algorithmic paradigm that follows
the problem solving heuristic of making the locally optimal
choice at each stage with the hope of finding a global
optimum.

26. Usage of greedy algorithm
• The greedy choice property: A globally optimal solution can
be arrived at by making a locally optimal (greedy) choice.
• The optimal substructure property:The optimal solution
contains within its optimal solutions to subproblems.

27. Method
• Casting the optimization problem as one for which:
we make a choice and are left with only one sub problem to solve
• Proving the greedy choice:
there is always an optimal solution to the original problem that
makes the greedy choice
• Proving the optimal structure:
the greedy choice + an optimal solution to the resulting Sub
problem leads to an optimal solution.

28. Simple Example on greedy Algorithm
method
• $6.64 = $2 +$2 + $1 + $1
.25 + .25 + .10 +
.01 + .01 + .01 +.01
• 10$= $5 + $5

29. When Greedy Algorithm Fails
The summation of two 5$ is 10$ but the summation of three 5$
cannot be 10 if its fixed.
For example,
$5 + $5 = $10
But,
$5 + $5 + $5 ≠ $10

30. Importance of Algorithm Design
• It is used to store and access large quantities of data
efficiently.
• It is used to solve complex computational problems and to
design of good programs
• It is important to justify an algorithm correctness
mathematically
• It provides clear , simple and unambiguous description

31. Conclusion
• At last it may said that , the so called program name
Algorithm design is one of the most enforceable solution
program that can be used to solve any complicated , complex
, and hard program.
• Under considering the above case the concerned authority
included the jubilant students should prefer this program with
great care.