Searching

1. Searching Chapter 10

2. Chapter Contents • The Problem • Searching an Unsorted Array • Iterative Sequential Search • Recursive Sequential Search • Efficiency of Sequential Search • Searching a Sorted Array • Sequential search • Binary Search • Java Class Library: the Method binarySearch • Searching an Unsorted Chain • Iterative Sequential Search • Recursive Sequential Search • Efficiency of Sequential Search of a Chain • Searching a Sorted Chain • Sequential Search • Binary Search • Choosing a Search Method

3. The Problem Fig. 1 Searching is an every day occurrence.

4. Searching an Unsorted Array • A method that uses a loop to search an array. public boolean contains(Object anEntry) { boolean found = false;for (int index = 0; !found && (index < length); index++) { if (anEntry.equals(entry[index])) found = true; } // end forreturn found;} // end contains

5. Searching an Unsorted Array Fig. 2 An iterative sequential search of an array that (a) finds its target; (b) does not find its target

6. Searching an Unsorted Array • Pseudocode for a recursive algorithm to search an array. Algorithm to search a[first] through a[last] for desiredItemif (there are no elements to search)return falseelse if (desiredItem equals a[first])return trueelse return the result of searching a[first+1] through a[last]

7. Searching an Unsorted Array Fig. 3 A recursive sequential search of an array that (a) finds its target; (b) does not find its target.

8. Efficiency of a Sequential Search • Best case O(1) • Locate desired item first • Worst case O(n) • Must look at all the items • Average case O(n) • Must look at half the items • O(n/2) is still O(n)

9. Searching a Sorted Array • A sequential search can be more efficient if the data is sorted Fig. 4 Coins sorted by their mint dates.

10. Binary Search of Sorted Array Fig. 5 Ignoring one-half of the data when the data is sorted.

11. Binary Search of Sorted Array • Algorithm for a binary search Algorithm binarySearch(a, first, last, desiredItem)mid = (first + last)/2 // approximate midpointif (first > last)return falseelse if (desiredItem equals a[mid])return trueelse if (desiredItem < a[mid])return binarySearch(a, first, mid-1, desiredItem)else // desiredItem > a[mid]return binarySearch(a, mid+1, last, desiredItem)

12. Binary Search of Sorted Array Fig. 6 A recursive binary search of a sorted array that (a) finds its target;

13. Binary Search of Sorted Array Fig. 6 A recursive binary search of a sorted array that (b) does not find its target.

14. Java Class Library: The Method binarySearch • The class Arrays in java.util defines versions of a static method with following specification: /** Task: Searches an entire array for a given item.* @param array the array to be searched* @param desiredItem the item to be found in the array* @return index of the array element that equals desiredItem;* otherwise returns -belongsAt-1, where belongsAt is* the index of the array element that should contain* desiredItem */public static int binarySearch(type[] array, type desiredItem);

15. Efficiency of a Binary Search • Best case O(1) • Locate desired item first • Worst case O(log n) • Must look at all the items • Average case O(log n)

16. Iterative Sequential Search of an Unsorted Chain Fig. 7 A chain of linked nodes that contain the entries in a list.

17. Iterative Sequential Search of an Unsorted Chain • Implementation of iterative sequential search public boolean contains(Object anEntry){ boolean found = false; Node currentNode = firstNode;while (!found && (currentNode != null)) { if (anEntry.equals(currentNode.getData())) found = true;elsecurrentNode = currentNode.getNextNode(); } // end whilereturn found;} // end contains

18. Recursive Sequential Search of an Unsorted Chain • Recursive search method /** Task: Recursively searches a chain of nodes for desiredItem,* beginning with the node that current references. */private boolean search(Node current, Object desiredItem){ boolean found;if (current = = null) found = false;else if (desiredItem.equals(current.getData())) found = true;elsefound = search(current.getNextNode(), desiredItem);return found;} // end search

19. Efficiency of a Sequential Search of a Chain • Best case O(1) • Locate desired item first • Worst case O(n) • Must look at all the items • Average case O(n) • Must look at half the items • O(n/2) is just O(n)

20. Searching a Sorted Chain • Method to search a sorted chain public boolean contains(Object anEntry){ boolean found = false; Comparable entry = (Comparable)anEntry; Node currentNode = firstNode;while ( (currentNode != null) && (entry.compareTo(currentNode.getData()) > 0) ) { currentNode = currentNode.getNextNode(); } // end whileif ( (currentNode != null) && entry.equals(currentNode.getData()) ) { found = true; } // end ifreturn found;} // end contains Note: Binary search of a chain of linked nodes is impractical.

21. Choosing a Search Method • Iterative search saves time, memory over recursive search