1 / 21

Searching

Searching. Chapter 10. 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

lynde
Download Presentation

Searching

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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

More Related