1. CS212: DATASTRUCTURES Lecture 3: Searching 1

2. Lecture Contents  searching  Sequential search algorithm.  Binary search algorithm. 2

3. Search Algorithms  Searching, the process used to find the location of a target among a list of objects.  In this chapter, we will study searches that work with arrays Search Algorithms Sequential Search Binary Search 3

4. Search Algorithms 1. Sequential search. 1. It’s not requires an ordered list. 2. Binary search.  It requires an ordered list. 4

5. 1/ Sequential (Linear) Search 5  Search an array or list by checking items one at a time.  Sequential search is usually very simple to implement, and is practical when the list has only a few elements, or when performing a single search in an unordered list.  Look at every element : This is a very straightforward loop comparing every element in the array with the target(key).  Eighter we find it,  or we reach the end of the list!

6. Locating data in unordered list. 6

7. Sequential Search Algorithm  The searching algorithm requires three parameters: 1. The list. 2. An index to the last element in the list. 3. The target. 7

8. Sequential Search Algorithm algorithm SeqSearch (val list, val last, val target ) Locate the target in an unordered list of size elements. PRE list must contain at least one element. last is index to last element in the list. target contains the data to be located. POST if found – matching index stored in Location. if not found – (-1) stored in Location RETURN Location 8

9. Sequential Search Algorithm looker = 0 loop (looker < last AND target not equal list(looker)) looker = looker + 1 if (target == list[looker] ) Location= looker else Location = -1 End If return Location end SeqSearch 9

10. Recursive Sequential Search Algorithm algorithm RecSeqsearch (val I ), val J ), val target ) Locate the target in an unordered list of size elements. PRE I is is index to first element in the list. last is index to last element in the list. target contains the data to be located. POST if found – matching index stored in Location. if not found – (-1) stored in Location RETURN Location 10

11. Recursive Sequential Search Algorithm 11 if (A[I] == target) location = I else if (I == J) location = -1 else location = RecSeqsearch(I+1,J, target) End If Return location End RecSeqsearch

12. Recursive sequential search (2) 12 Algorithm sequentialSearch (item,list, listSize ) Pre item contains a value, listSize contains the actual size of the array list Post find the location of item in list Return either the item found and its location is returned or not and -1 returned if (listSize == 0) return -1 if (list[listSize-1] == item) return listSize-1 else return sequentialSearch (item, list, listSize-1) End sequentialSearch

13. 2/ Binary search algorithm  Search a sorted array by repeatedly dividing the search interval in half.  A fast way to search a sorted array is to use a binary search. 13

14. Binary search algorithm Test the data in the element at the middle of the array. it is in the first half before middle it is in the second half after middle Test the data in the element at the middle of the array. it is in the second half! it is in the second half! it is in the second half! it is in the second half! it is in the first half! it is in the first half! it is in the first half! it is in the first half!................ Calculate the middle element If the middle element equals to the Target, the algorithm stops Target < middle element Target > middle element Target < middle Target > middle Calculate the middle element 14

15. target > A[mid] first = mid +1 15 target == A[mid] target < A[mid] last = mid -1 mid=(first+last)/2

16. 16 target < A[mid] last = mid -1 target > A[mid] first = mid +1 target < A[mid] last = first  not found  stop target > A[mid] first = mid +1

17. Recursive Binary search algorithm algorithm RecBinarySearch (val First, val last,val target ) Locate the target in an ordered list of size elements. PRE list must contain at least one element. First is index to first element in the list. last is index to last element in the list. target contains the data to be located. POST if found – matching index stored in Location if not found – (-1) stored in Location RETURN Location 17

18. Recursive search algorithm m := if target = a m then Location= m else if (first=last) then Location= -1 else if (target < a m ) then Location =binarySearch(first, m-1, target) else if (target > a m ) then Location=binarySearch(m+1, last, target ) Return Location End RecBinarySearch base cases recursive calls 18

19. Example 19 [4][3][2][1][0] 2011753 BinarySearch (0,4,20) M=0+4/2=2 20 >7 then binarySearch(3, 4,20) BinarySearch (0,4,20) M=0+4/2=2 20 >7 then binarySearch(3, 4,20) BinarySearch (3,4,20) M=3+4/2=3 20 >11 then binarySearch(4, 4,20) BinarySearch (3,4,20) M=3+4/2=3 20 >11 then binarySearch(4, 4,20) BinarySearch (4,4,20) M=4+4/2=2 20 == 20 BinarySearch (4,4,20) M=4+4/2=2 20 == 20 Return 4 Recursive call

20. Binary search algorithm (iterative) 20 Algorithm BinarySearch (list, key, listSize ) Search an ordered list using Binary Search PRE list must contain at least one element. listSize is the actual size of the list. key contains the data to be located. POST if found – matching index stored in Location if not found (-1) stored in Location RETURN Location

21. Binary search in iterative algorithm 21 first=0 last=listSize-1 while (first<= last) { mid = if ( list [mid] == key) return mid else if (list[mid] < key) first = mid + 1 else last = mid - 1 } return -1 End BinarySearch

22. References: Text book, chapter2: Searching End Of Chapter 22