Searching

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

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;

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; }

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

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 lo hi mid

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 lo hi

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 lo midhi

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 lohi

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 lohimid

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 lo hi

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 lo hi mid

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 lo hi mid

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 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); }

Sorting

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 Example of Bubble Sort (done) Stage 1Stage 2Stage 3 Stage 4

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 Insertion Sort

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 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 Example of first step AInsert x = 15

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

28 Example of first step AInsert x = 15 Compare with 22. x < 22, so move 22 right Compare with 20. x < 20, so move 20 right

29 Example of first step 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 Sort using the insertion 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,

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 Look at the sorting! 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 Mergesort

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 Merging Two Sorted Arrays 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.

37 Merge Code 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 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); }