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. 82134657109111214130 64141325335143538472939597966 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. 82134657109111214130 64141325335143538472939597966 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. 82134657109111214130 64141325335143538472939597966 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. 82134657109111214130 64141325335143538472939597966 lo midhi

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. 82134657109111214130 64141325335143538472939597966 lohi

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. 82134657109111214130 64141325335143538472939597966 lohimid

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. 82134657109111214130 64141325335143538472939597966 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. 82134657109111214130 64141325335143538472939597966 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. 82134657109111214130 64141325335143538472939597966 lo hi mid

17. 17 Example: Binary Search Searching for an element k in a sorted array A with n elements Idea: n Choose the middle element A[n/2] n If k == A[n/2], we are done n If k < A[n/2], search for k between A[0] and A[n/2 - 1] n If k > A[n/2], search for k between A[n/2 + 1] and A[n-1] n Repeat until either k is found, or no more elements to search Requires less number of comparisons than linear search in the worst case (log 2 n 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 found\n”, k); break; } if (k < A[mid]) high = mid – 1; else low = mid + 1; mid = (high + low)/2; } If (high < low) printf(“%d is not found\n”, k); }

19. Sorting

20. 20 Bubble Sort Stage 1: Compare each element (except the last one) with its neighbor to the right n If they are out of order, swap them n This puts the largest element at the very end n 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 n If they are out of order, swap them n This puts the second largest element next to last n 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 n Continue as above until you have no unsorted elements on the left

21. 21 Example of Bubble Sort 7 2854 2 7854 2 7854 2 7584 2 7548 2 7548 2 5748 2 5478 2 7548 2 5478 2 4578 2 5478 2 4578 2 4578 (done) Stage 1Stage 2Stage 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 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: n Insert A[1] in the sorted array A[0]. So now A[0],A[1] are sorted n Insert A[2] in the sorted array A[0],A[1]. So now A[0],A[1],A[2] are sorted n 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 n ….. n Insert A[i] in the sorted array A[0],A[1],…,A[i-1]. So now A[0],A[1],…A[i] are sorted n Continue until i = n-1 (outer loop)

25. 25 How to do the first step Compare x with A[k-1] (the last element) n If x ≥ A[k-1], we can make A[k] = x (as x is the max of all the elements) n 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 5711132022 AInsert x = 15

27. 27 Example of first step 5711132022 571113201522 AInsert x = 15 Compare with 22. x < 22, so move 22 right

28. 28 Example of first step 5711132022 571113201522 571113152022 AInsert 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 5711132022 571113201522 571113152022 571113152022 AInsert 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 7513112220 5713112220 5713112220 5711132220 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 5711132022 5711132220

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 once finally also */ } 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 34789 257 2 34789 257 23 34789 257 234 34789 257 Problem : Two sorted arrays A and B are given. We are required to produce a final sorted array C which contains all elements of A and B.

36. 36 2345 34789 257 23457 34789 257 234577 34789 257 2345778 34789 257

37. 37 Merge Code 23457789 34789 257 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); }