The document describes various search and sorting algorithms including linear search, binary search, bubble sort, and insertion sort. It provides detailed explanations, including algorithms' steps, code examples, and the logic behind each method. Additionally, it highlights the efficiency of search methods like binary search compared to linear search and outlines how sorting algorithms operate to organize data.

1. Searching

2. The process used to find the location
of a target among a list of objects
Searching an array finds the index of first element in an array
containing that value
Searching

5. Unordered Linear Search
Search an unordered array of integers for a value and return its index if
the value is found. Otherwise, return -1.
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
Algorithm:
Start with the first array element (index 0)
while(more elements in array){
if value found at current index, return
index;
Try next element (increment index);
}
Value not found, return -1;
14 2 10 5 1 3 17 2

6. Unordered Linear Search
// Searches an unordered array of integers
int search(int data[], //input: array
int size, //input: array size
int value){ //input: search value
// output: if found, return index;
// otherwise, return –1.
for(int index = 0; index < size; index++){
if(data[index] == value)
return index;
}
return -1;
}

8. 8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
Binary Search
lo
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
hi

9. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo hi
mid

10. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo hi

11. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo mid hi

12. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo hi

13. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo hi
mid

14. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo
hi

15. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo
hi
mid

16. Binary Search
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo
hi
mid

17. 17
Example: Binary Search
Searching for an element k in a sorted array A with n
elements
Idea:
 Choose the middle element A[n/2]
 If k == A[n/2], we are done
 If k < A[n/2], search for k between A[0] and A[n/2 -
1]
 If k > A[n/2], search for k between A[n/2 + 1] and
A[n-1]
 Repeat until either k is found, or no more elements
to search
Requires less number of comparisons than linear
search in the worst case (log2n instead of n)

18. 18
int main() {
int A[100], n, k, i, mid, low, high;
scanf(“%d %d”, &n, &k);
for (i=0; i<n; ++i)
scanf(“%d”, &A[i]);
low = 0; high = n – 1; mid = (high + low)/2;
while (high >= low) {
if (A[mid] == k) {
printf(“%d is foundn”, k);
break;
}
if (k < A[mid]) high = mid – 1;
else
low = mid + 1;
mid = (high + low)/2;
}
If (high < low) printf(“%d is not foundn”, k);
}

19. Sorting

20. 20
Bubble Sort
Stage 1: Compare each element (except the last one) with
its neighbor to the right
 If they are out of order, swap them
 This puts the largest element at the very end
 The last element is now in the correct and final place
Stage 2: Compare each element (except the last two) with
its neighbor to the right
 If they are out of order, swap them
 This puts the second largest element next to last
 The last two elements are now in their correct and final places
Stage 3: Compare each element (except the last three)
with its neighbor to the right
 Continue as above until you have no unsorted elements on the left

21. 21
Example of Bubble Sort
7 2 8 5 4
2 7 8 5 4
2 7 8 5 4
2 7 5 8 4
2 7 5 4 8
2 7 5 4 8
2 5 7 4 8
2 5 4 7 8
2 7 5 4 8
2 5 4 7 8
2 4 5 7 8
2 5 4 7 8
2 4 5 7 8
2 4 5 7 8
(done)
Stage 1 Stage 2 Stage 3 Stage 4

22. 22
Code for Bubble Sort
void bubbleSort(int[] a) {
int stage, inner, temp;
for (stage = a.length - 1; stage > 0; stage--) { // counting down
for (inner = 0; inner < stage; inner++) { // bubbling up
if (a[inner] > a[inner + 1]) { // if out of order...
temp = a[inner]; // ...then swap
a[inner] = a[inner + 1];
a[inner + 1] = temp;
}
}
}
}

23. 23
Insertion Sort

24. 24
Insertion Sort
Suppose we know how to insert a new element x in its proper
place in an already sorted array A of size k, to get a new
sorted array of size k+1
Use this to sort the given array A of size n as follows:
 Insert A[1] in the sorted array A[0]. So now A[0],A[1] are
sorted
 Insert A[2] in the sorted array A[0],A[1]. So now
A[0],A[1],A[2] are sorted
 Insert A[3] in the sorted array A[0],A[1],A[2]. So now
A[0],A[1],A[2],A[3] are sorted
 …..
 Insert A[i] in the sorted array A[0],A[1],…,A[i-1]. So now
A[0],A[1],…A[i] are sorted
 Continue until i = n-1 (outer loop)

25. 25
How to do the first step
Compare x with A[k-1] (the last element)
 If x ≥ A[k-1], we can make A[k] = x (as x is the max
of all the elements)
 If x < A[k-1], put A[k] = A[k-1] to create a hole in
the k-th position, put x there
Now repeat by comparing x with A[k-2] (inserting x in
its proper place in the sorted subarray
A[0],A[1],…A[k-1] of k-2 elements)
The value x bubbles to the left until it finds an
element A[i] such that x ≥ A[i]
No need to compare any more as all elements A[0],
A[1], A[i] are less than x

26. 26
Example of first step
5 7 11 13 20 22
A Insert x = 15

27. 27
Example of first step
5 7 11 13 20 22
5 7 11 13 20 15 22
A Insert x = 15
Compare with 22. x < 22, so move 22 right

28. 28
Example of first step
5 7 11 13 20 22
5 7 11 13 20 15 22
5 7 11 13 15 20 22
A Insert x = 15
Compare with 22. x < 22, so move 22 right
Compare with 20. x < 20, so move 20 right

29. 29
Example of first step
5 7 11 13 20 22
5 7 11 13 20 15 22
5 7 11 13 15 20 22
5 7 11 13 15 20 22
A Insert x = 15
Compare with 22. x < 22, so move 22 right
Compare with 20. x < 20, so move 20 right
Compare with 13. x > 13, so stop
A

30. 30
Sort using the insertion
7 5 13 11 22 20
5 7 13 11 22 20
5 7 13 11 22 20
5 7 11 13 22 20
A
Insert 5 in 7
Insert 13 in 5, 7
Insert 11 in 5, 7, 13
Insert 22 in 5, 7, 11, 13
Insert 20 in 5, 7, 11, 13, 22
5 7 11 13 20 22
5 7 11 13 22 20

31. 31
Insertion Sort Code
void InsertionSort (int A[ ], int size)
{
int i, j, item;
for (i=1; i<size; i++)
{ /* Insert the element in A[i] */
item = A[i] ;
for (j = i-1; j >= 0; j--)
if (item < A[j])
{ /* push elements down*/
A[j+1] = A[j];
A[j] = item ; /* can do this on
}
else break; /*inserted, exit loop */
}
}

32. 32
Look at the sorting!
8
2
9
4
7
6
2
1
5
i = 1:: 2, 9, 4, 7, 6, 2, 1, 5
i = 2:: 9, 2, 4, 7, 6, 2, 1, 5
i = 3:: 9, 4, 2, 7, 6, 2, 1, 5
i = 4:: 9, 7, 4, 2, 6, 2, 1, 5
i = 5:: 9, 7, 6, 4, 2, 2, 1, 5
i = 6:: 9, 7, 6, 4, 2, 2, 1, 5
i = 7:: 9, 7, 6, 4, 2, 2, 1, 5
Result = 9, 7, 6, 5, 4, 2, 2, 1
void InsertionSort (int A[ ], int size) {
int i,j, item;
for (i=1; i<size; i++) {
printf("i = %d:: ",i);
for (j=0;j<size;j++) printf("%d, ",A[j]);
printf("n"); item = A[i] ;
for (j=i-1; j>=0; j--)
if (item > A[j])
{ A[j+1] = A[j]; A[j] = item ; }
else break;
}
int main() {
int X[100], i, size;
scanf("%d",&size);
for (i=0;i<size;i++) scanf("%d",&X[i]);
InsertionSort(X,size);
printf("Result = ");
for (i=0;i<size;i++) printf("%d, ",X[i]);
printf("n"); return 0;
}

33. 33
Mergesort

34. 34
Basic Idea
Divide the array into two halves
Sort the two sub-arrays
Merge the two sorted sub-arrays into a single
sorted array
Step 2 (sorting the sub-arrays) is done
recursively (divide in two, sort, merge) until
the array has a single element (base
condition of recursion)

35. 35
Merging Two Sorted Arrays
3 4 7 8 9
2 5 7
2
3 4 7 8 9
2 5 7
2 3
3 4 7 8 9
2 5 7
2 3 4
3 4 7 8 9
2 5 7
Problem: Two sorted arrays A and B are given. We are required
produce a final sorted array C which contains all elements of A

36. 36
2 3 4 5
3 4 7 8 9
2 5 7
2 3 4 5 7
3 4 7 8 9
2 5 7
2 3 4 5 7 7
3 4 7 8 9
2 5 7
2 3 4 5 7 7 8
3 4 7 8 9
2 5 7

37. 37
Merge Code
2 3 4 5 7 7 8 9
3 4 7 8 9
2 5 7
void
merge (int A[], int B[], int C[], int m,int n)
{
int i=0,j=0,k=0;
while (i<m && j<n)
{
if (A[i] < B[j]) C[k++] = A[i++];
else C[k++] = B[j++];
}
while (i<m) C[k++] = A[i++];
while (j<n) C[k++] = B[j++];
}

38. 38
Merge Sort: Sorting an array
recursively
void mergesort (int A[], int n)
{
int i, j, B[max];
if (n <= 1) return;
i = n/2;
mergesort(A, i);
mergesort(A+i, n-i);
merge(A, A+i, B, i, n-i);
for (j=0; j<n; j++) A[j] = B[j];
free(B);
}