Searching

Document Sample
Searching Powered By Docstoc
					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
        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

                                                           2
The Problem




    Fig. 1 Searching is an every day occurrence.
                                                   3
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 for
         return found;
     } // end contains
                                                                    4
Searching an Unsorted Array




   Fig. 2 An iterative sequential search of an array that
       (a) finds its target; (b) does not find its target   5
Searching an Unsorted Array
   Pseudocode for a recursive algorithm to
    search an array.
      Algorithm to search a[first] through a[last] for desiredItem
      if (there are no elements to search)
            return false
      else if (desiredItem equals a[first])
            return true
      else
            return the result of searching a[first+1] through a[last]




                                                                        6
Searching an Unsorted Array




    Fig. 3 A recursive sequential
 search of an array that (a) finds its
 target; (b) does not find its target.   7
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)


                                        8
Searching a Sorted Array
   A sequential search can be more efficient if
    the data is sorted




            Fig. 4 Coins sorted by their mint dates.

                                                       9
Binary Search of Sorted Array




      Fig. 5 Ignoring one-half of the data
                                             10
            when the data is sorted.
Binary Search of Sorted Array
   Algorithm for a binary search
      Algorithm binarySearch(a, first, last, desiredItem)
      mid = (first + last)/2 // approximate midpoint
      if (first > last)
           return false
      else if (desiredItem equals a[mid])
           return true
      else if (desiredItem < a[mid])
           return binarySearch(a, first, mid-1, desiredItem)
      else // desiredItem > a[mid]
           return binarySearch(a, mid+1, last, desiredItem)
                                                               11
Binary Search of Sorted Array




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




    Fig. 6 A recursive binary search of a sorted
                                                   13
       array that (b) does not find its target.
    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);

                                                                        14
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)



                                          15
Iterative Sequential Search of an
Unsorted Chain




     Fig. 7 A chain of linked nodes that contain
                 the entries in a list.

                                                   16
    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;
                   else
                        currentNode = currentNode.getNextNode();
             } // end while
             return found;
       } // end contains
                                                                   17
    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;
            else
                  found = search(current.getNextNode(), desiredItem);
            return found;
      } // end search
                                                                         18
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)
                                         19
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 while
              if ( (currentNode != null) &&
                    entry.equals(currentNode.getData()) )
              { found = true;
              } // end if                Note: Binary search of a chain
              return found;              of linked nodes is impractical.
                                                                           20
        } // end contains
Choosing a Search Method
                        Best   Average     Worst
                        Case    Case       Case
    Sequential search
                        O(1)     O(n)       O(n)
    (unsorted data)
    Sequential search
                        O(1)     O(n)       O(n)
    (sorted data)
    Binary Search
                        O(1)    O(log n)   O(log n)
    (sorted array)

   Iterative search saves time, memory over
    recursive search
                                                      21

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:8
posted:9/7/2011
language:English
pages:21