Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Chapter 8 Search Algorithms Data Structures Using Java 1 Chapter Objectives • Learn the various search algorithms • Explore how to implement the sequential and binary search algorithms • Discover how the sequential and binary search algorithms perform • Become aware of the lower bound on comparisonbased search algorithms • Learn about hashing Data Structures Using Java 2 class ArrayListClass: Basic Operations • • • • • • • • isEmpty isFull listSize maxListSixe Print isItemAtEqual insertAt insertEnd • • • • • • • • removeAt retrieveAt replaceAt clearList seqSearch insert remove copyList Data Structures Using Java 3 Search Algorithms • Associated with each item in a data set is a special member (the key of the item) that uniquely identifies the item in the data set • Keys are used in such operations as searching, sorting, insertion, and deletion • Analysis of the algorithms enables programmers to decide which algorithm to use for a specific application Data Structures Using Java 4 Sequential Search • Starts at the first element in the list • Continues until either the item is found in the list or the entire list is searched • Works the same for both array-based and linked lists Data Structures Using Java 5 Sequential Search public int seqSearch(DataElement searchItem) { int loc; boolean found = false; for(loc = 0; loc < length; loc++) if(list[loc].equals(searchItem)) { found = true; break; } if(found) return loc; else return -1; }//end seqSearch Data Structures Using Java 6 Search Algorithms • Search item: target • To determine the average number of comparisons in the successful case of the sequential search algorithm: – Consider all possible cases – Find the number of comparisons for each case – Add the number of comparisons and divide by the number of cases Data Structures Using Java 7 Sequential Search Analysis Suppose that there are n elements in the list. The following expression gives the average number of comparisons: It is known that Therefore, the following expression gives the average number of comparisons made by the sequential search in the successful case: Data Structures Using Java 8 Ordered Lists as Arrays • List is ordered if its elements are ordered according to some criteria • Elements of a list usually in ascending order • Define ordered list as an ADT Data Structures Using Java 9 Ordered Lists as Arrays • Several operations can be performed on an ordered list; similar to the operations performed on an arbitrary list – – – – Determining whether the list is empty or full Determining the length of the list Printing the list Clearing the list • Using inheritance, derive class to implement ordered lists from class ArrayListClass Data Structures Using Java 10 Binary Search Algorithm • Very fast • Uses “divide and conquer” technique to search list • First, search item compared with middle element of list • If the search item is less than middle element of list, restrict the search to first half of list • Otherwise, search second half of list Data Structures Using Java 11 Binary Search Data Structures Using Java 12 Binary Search: middle element mid = first + last 2 Data Structures Using Java 13 Binary Search public int binarySearch(DataElement item) { int first = 0; int last = length - 1; int mid = -1; boolean found = false; while(first <= last && !found) { mid = (first + last) / 2; if(list[mid].equals(item)) found = true; else if(list[mid].compareTo(item) > 0) last = mid - 1; else first = mid + 1; } if(found) return mid; else return -1; }//end binarySearch Data Structures Using Java 14 Binary Search: Example Data Structures Using Java 15 Binary Search: Example • Unsuccessful search • Total number of comparisons is 6 Data Structures Using Java 16 Performance of Binary Search Data Structures Using Java 17 Performance of Binary Search Data Structures Using Java 18 Performance of Binary Search • Unsuccessful search – for a list of length n, a binary search makes approximately 2*log2(n + 1) key comparisons • Successful search – for a list of length n, on average, a binary search makes 2*log2n – 4 key comparisons Data Structures Using Java 19 Algorithm to Insert into an Ordered List Use algorithm similar to binary search algorithm to find place where item is to be inserted if the item is already in this list output an appropriate message else use the method insertAt to insert the item in the list Data Structures Using Java 20 Search Algorithm Analysis Summary Data Structures Using Java 21 Lower Bound on ComparisonBased Search • Theorem: Let L be a list of size n > 1. Suppose that the elements of L are sorted. If SRH(n) denotes the minimum number of comparisons needed, in the worst case, by using a comparison-based algorithm to recognize whether an element x is in L, then SRH(n) = log2(n + 1). • Corollary: The binary search algorithm is the optimal worst-case algorithm for solving search problems by the comparison method. Data Structures Using Java 22 Hashing • Main objectives to choosing hash methods: – Choose a hash method that is easy to compute – Minimize the number of collisions Data Structures Using Java 23 Commonly Used Hash Methods • Mid-Square – Hash method, h, computed by squaring the identifier – Using appropriate number of bits from the middle of the square to obtain the bucket address – Middle bits of a square usually depend on all the characters, it is expected that different keys will yield different hash addresses with high probability, even if some of the characters are the same Data Structures Using Java 24 Commonly Used Hash Methods • Folding – Key X is partitioned into parts such that all the parts, except possibly the last parts, are of equal length – Parts then added, in convenient way, to obtain hash address • Division (Modular arithmetic) – Key X is converted into an integer iX – This integer divided by size of hash table to get remainder, giving address of X in HT Data Structures Using Java 25 Commonly Used Hash Methods Suppose that each key is a string. The following Java method uses the division method to compute the address of the key: int hashmethod(String insertKey) { int sum = 0; for(int j = 0; j <= insertKey.length(); j++) sum = sum + (int)(insertKey.charAt(j)); return (sum % HTSize); }//end hashmethod Data Structures Using Java 26 Collision Resolution • Algorithms to handle collisions • Two categories of collision resolution techniques – Open addressing (closed hashing) – Chaining (open hashing) Data Structures Using Java 27 Open Addressing: Linear Probing • Suppose that an item with key X is to be inserted in HT • Use hash function to compute index h(X) of item in HT • Suppose h(X) = t. Then 0 = h(X) = HTSize – 1 • If HT[t] is empty, store item into array slot. • Suppose HT[t] already occupied by another item; collision occurs • Linear probing: starting at location t, search array sequentially to find next available array slot Data Structures Using Java 28 Collision Resolution: Open Addressing Pseudocode implementing linear probing: hIndex = hashmethod(insertKey); found = false; while(HT[hIndex] != emptyKey && !found) if(HT[hIndex].key == key) found = true; else hIndex = (hIndex + 1) % HTSize; if(found) System.out.println(”Duplicate items not allowed”); else HT[hIndex] = newItem; Data Structures Using Java 29 Linear Probing Data Structures Using Java 30 Linear Probing Data Structures Using Java 31 Random Probing • Uses a random number generator to find the next available slot • ith slot in the probe sequence is: (h(X) + ri) % HTSize where ri is the ith value in a random permutation of the numbers 1 to HTSize – 1 • All insertions and searches use the same sequence of random numbers Data Structures Using Java 32 Quadratic Probing • Reduces primary clustering • We do not know if it probes all the positions in the table • When HTSize is prime, quadratic probing probes about half the table before repeating the probe sequence Data Structures Using Java 33 Deletion: Open Addressing • In open addressing, when an item is deleted, its position in the array cannot be marked as empty Data Structures Using Java 34 Deletion: Open Addressing Data Structures Using Java 35 Deletion: Open Addressing Data Structures Using Java 36 Chaining • For each key X (in item), find h(X) = t, where 0 = t = HTSize – 1. Item with this key inserted in linked list (which may be empty) pointed to by HT[t]. • For nonidentical keys X1 and X2, if h(X1) = h(X2), items with keys X1 and X2 inserted in same linked list • To delete an item R, from hash table, search hash table to find where in linked list R exists. Then adjust links at appropriate locations and delete R Data Structures Using Java 37 Collision Resolution: Chaining (Open Hashing) Data Structures Using Java 38 Hashing Analysis Let Then a is called the load factor Data Structures Using Java 39 Linear Probing: Average Number of Comparisons 1. Successful search 2. Unsuccessful search Data Structures Using Java 40 Quadratic Probing: Average Number of Comparisons 1. Successful search 2. Unsuccessful search Data Structures Using Java 41 Chaining: Average Number of Comparisons 1. Successful search 2. Unsuccessful search Data Structures Using Java 42 Chapter Summary • Search Algorithms – Sequential – Binary • Algorithm Analysis • Hashing – Hash Table – Hash method – Collision Resolution Data Structures Using Java 43