Hash table basics mod 83 ate. ate. hashcode()

Transcription

1 Hash table basics ate hashcode() mod 83 ate

2 Reminder from syllabus: EditorTrees worth 10% of term grade See schedule page Exam 2 moved to Friday after break. Short pop quiz over AVL rotations now

3 T F IDK Format same as Exam 1 One 8.5x11 sheet of paper (2-sided) for written part Same resources as before for programming part Topics: weeks 1-6 Reading, programs, in-class, written assignments. Especially Using various data structures (lists, stacks, queues, sets, maps, priority queues) Binary trees, including BST, AVL, and threaded Traversals and iterators, size vs. height, rank Backtracking / Queens problem Hash tables Algorithm analysis in general Through day 19, WA6, and EditorTrees milestone 2 Sample exam on Moodle has some good questions (and extras we haven t done, like sorting) Best practice: written assignments.

4

5 Hash table basics Collision resolution EditorTrees work time

6 Efficiently putting 5 pounds of data in a 20 pound bag

7 1 Provides rapid insertion, retrieval, and deletion of items by key HashMap uses a hash table internally Actual table data is stored in an array HashSet uses a HashMap internally Insertion and lookup are constant time! With a good hash function And large enough storage array On average

8 If we have a collection of n elements whose keys are unique integers in the range 0.. m-1, where m >= n, then we can store the items in a direct address table, T[m], where T i is either empty or contains one of the elements of our collection Contents of this slide are from John Morris, University of Western Australia Searching a direct address table is clearly an O(1) operation: for a key, k, we access T k, if it contains an element, return it, if it doesn't, then return a NULL

9 There are two major constraints: 1. the keys must be unique 2. the range of possible keys must be severely bounded Contents of this slide are from John Morris, University of Western Austrailia The second constraint is usually impossible to meet

10 2 key hashcode() integer A good hashcode() distributes the keys, like: hashcode( ate )= hashcode( ape )= hashcode( awe ) =

11 Example: if m = 100: hashcode( ate )= hashcode( ape )= hashcode( awe ) = mod

12 3-4 Every Java object has a hashcode method that returns an integer H The hash table uses H % m as the index into its internal array ate hashcode() mod 83 ate Unless this position is already occupied a collision

13 Should we inherit it? JDK classes override the hashcode() method Like String If you plan to use instances of your class as keys in a hash table, you probably should too!

14 Should be fast to compute Should distribute keys as evenly as possible These two goals are often contradictory; we need to achieve a balance

15 // This could be in the String class public static int hash(string s) { int total = 0; for (int i=0; i<s.length(); i++) total = total + s.charat(i); return Math.abs(total); } Advantages? Disadvantages?

16 // This could be in the String class public static int hash(string s) { int total = 0; for (int i=0; i<s.length(); i++) total = total*256 + s.charat(i); return Math.abs(total); } Spreads out the values more, and anagrams not an issue. What about overflow during computation?

17 // This could be in the String class public static int hash(string s) { int total = 0; for (int i=0; i<s.length(); i++) total = total*23 + s.charat(i); return Math.abs(total); } Spreads out the values more, and anagrams not an issue. We can't entirely avoid collisions. Why? What about overflow during computation? Note: String already has a reasonable hashcode() method; we don't have to write it ourselves.

18 5 Objects that are equal (based on the equals method) MUST have the same hashcode values Different objects should have different hashcodes if possible Beware of mutable objects! Hash tables don t maintain sorted order So what s the big-o cost to find min or max element?

19 A hash table implementation (like HashMap) provides a collision resolution mechanism There are a variety of approaches to this Fewer collisions lead to faster performance

20 6 Just make hashcode unique? Impossible! possible key values >> capacity of table Example: A key may be an array of 16 characters How many different values could there be? So we need to deal with collisions: Probing (Linear, Quadratic) Chaining

21 7 Collision? Use the next available space: Try H+1, H+2, H+3, Wraparound at the end of the array Problem: Clustering Animation: ash_tables.html

22 Figure 20.4 Linear probing hash table after each insertion Data Structures & Problem Solving using JAVA/2E Mark Allen Weiss 2002 Addison Wesley

23 8 Depends on Load Factor, λ: Ratio of the number of items stored to table size 0 λ 1. For a given λ, what is the expected number of probes before an empty location is found?

24 For a given λ, what is the expected number of probes before an empty location is found? Assume all locations are equally likely to be occupied, and equally likely to be the next one we look at. Then the probability that a given cell is full is λ and probability that a given cell is empty is 1-λ. What s the expected number? 9

25 10 Equally likely" probability is not realistic Clustering! Blocks of occupied cells are formed Any collision in a block makes the block bigger Two sources of collisions: Identical hash values Hash values that hit a cluster Actual average number of probes for large λ: For a proof, see Knuth, The Art of Computer Programming, Vol 3: Searching Sorting, 2nd ed, Addision-Wesley, Reading, MA, 1998.

26 Easy to implement Simple code has fast run time per probe Works well when load is low It could be more efficient just to rehash using a bigger table once it starts to fill. And in practice, once λ > 0.5, we usually double the size of the array and rehash

27 Linear probing: Collision at H? Try H, H+1, H+2, H+3,... Quadratic probing: Collision at H? Try H, H+1 2. H+2 2, H+3 2,... Eliminates primary clustering. Secondary clustering isn t as problematic

28 11 Choose a prime number p for the array size Then if λ 0.5: Guaranteed insertion If there is a hole, we ll find it No cell is probed twice See proof of Theorem 20.4: Suppose that we repeat a probe before trying more than half the slots in the table See that this leads to a contradiction Contradicts fact that the table size is prime

29 Use an algebraic trick to calculate next index Difference between successive probes yields: Probe i location, H i = (H i-1 + 2i 1) % M 1. Just use bit shift to multiply i by 2 probeloc= probeloc + (i << 1) - 1; faster than multiplication 2. Since i is at most M/2, can just check: if (probeloc >= M) probeloc -= M; faster than mod

30 No one has been able to analyze it! Experimental data shows that it works well Provided that the array size is prime, and λ < 0.5

31 Use an array of linked lists How would that help resolve collisions?

32 Java s HashMap uses chaining and a table size that is a power of 2. This table size avoids the mod operator for speed. But since it is suspectible to bad hashes, it always rehashes your hash code. 12

33 Immersion in tree manipulation