CS201 - Spring 2014 - Class 28
- office hours will start late ~10:30 on Tue.
quick recap of data structures
- No free lunch: there is no single best data structure
- different data structures (and different implementations of those structures) are good at different things
- What are the following structures good for/at?
- storing sequential data
- O(1) access to elements at particular indices
- ArrayLists allow for amortized O(1) adds
- Linked lists
- add/remove from beginning/end in O(1)
- can delete from the middle if we have a reference to the node
- Binary search trees
- If balanced, O(log n):
- good for min/max requests
- O(log n) add and extractMin/Max
- We've also looked at some meta-data structures that help facilitate certain operations
- we'd like to be able to support set-like data structures
- objects can be added
- and we can ask if an object belongs to a set
- look at the Set interface in
- can we support this type of thing with anything we have so far?
- binary search trees do this in O(log n)
- can we do better?
- are there additional things we can do with binary search trees that we don't need?
- there is still an ordering
- things like successor can be done quickly
- can print out the data in order
universe of keys
- we have some universe of keys (often called U) that we want to store, be it numbers, strings, objects, etc.
- for example:
- all Middlebury ID numbers
- all social security number
- all last names
- all names of people (first and last together)
- all tweets from today
- if you know the min and max key, any approach?
- store them in an array
- Any problems?
- for any given run, we don't need to store ALL keys, just a subset
- the array has to be at least the size of the universe of keys (all possible keys!)
- lost of wasted space
- a hash function is a function that maps the universe of keys to a restricted range, call it m, where m << |U|, that is m is much smaller than the universe of keys
- how does this help us?
- now we don't have to have an array of size |U|, just have to have an array of size m
- a hashtable is a data structure that uses an array of some sort to store the items. Using a hash function, any item is mapped to the array.
- to find if an item exists in the hash table, we hash the item and see if it exists in the table at the specified entry
- what can happen if m < |U|?
- we can have two things map to the same position in the array even though they're not equivalent, that is h(x) == h(y) even though !x.equals(y)
- this is called a "collision"
- a good hash function will try to avoid them but if m < |U|, they are inevitable
- pigeonhole principle: if n items are put into m pigeonholes with n > m, then at least on pigeonhole must contain more than one item
- simple idea, but often useful for proving things
- every object in java has a method called hashCode that returns an attempt at a unique integer for that object
- how does this happen?
- it's another method (like equals and toString) that is inherited from the Object class
- the hashCode method for Object is based on the objects location in memory and does a fairly good job of providing unique numbers, however...
- if you plan on using Maps or hashtables with an Object, you should consider overriding the hashCode method
- the two requirements of the hashCode method are (
- "Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified."
- "If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result."
- A number of the common classes (like String, Integer, etc) do have overridden hashCode methods