2004S, CSC153 Class 51: The Dictionary ADT
Admin:
* Interesting convo yesterday; Almost all the students there were there to have their name announced.
* Questions on HW 8?
* Hmmm ... there are 13 students preregistered for each of my two classes. (CSC152-CSII and CSC223-Software Design.)
* The picnic may move to the science elbow. Announcement at 1ish.
Overview:
* Dictionary Basics
* Applying Dictionaries
* Dictionary Methods
* Dictionaries vs. Databases
* Implementation 1: Lists
* Implementation 2: BSTs
The Dictionary ADT
* Philosophy
* Applications
* Methods
Philosophy of the Dictionary ADT
* Like arrays, but indexed by arbitrary objects rather than integers
* Typically, strings are used as the indices
* The indices are called "keys"
Applications:
* Build "real" dictionaries (associate a definition with a word)
* Indexing collections of stuff
* Counting words
* Sets
Design questions:
* Can you have more than one value associated with an index? Typically no.
* However, you can make a list the associated value.
* Are the keys homogenous or heterogeneous? All objects
* Are the associated values homogenous or hextexroxgenyqeous? All objects
Methods:
* Object get(Object key)
* If the key is not in the dictionary, could throw an exception or *return null*
* Returning null: A lot like arrays of objects: If you don't put something in a space, null is there.
* Object set(Object key, Object value)
* If the key is already in the dictionary, overwrite and return the old object
* Object getKey(Object value) - Returns *a* key of the object.
* Some iteration method
* Iterate key/value Pairs
* Iterate * keys
Iterate values ['Eh]
* Constructors
* Object remove(Object key)
* Vs. setting to null
* void clear()
* void dump(OutputStream pen) -> Better implemented by making it serializable?
* String toString()
Implementation (Data Structures):
* Philosophy
* Efficiency
* Details
Philsophy 1: Use an unordered list or an array. Put key/value pairs in the list or array.
* Efficiency:
* set: O(1): Replace the head and change your pointer; Whoops ... if it has to check for an existing key/value pair, O(n)
* get: O(n)
Philosophy 2: Use an ordered array (assumes keys can be compared)
* Efficiency:
* set: O(n), since we may have to "shove everything over"
* get: O(logn)
Philosophy 3: Use a tree (Binary Search Trees: BST) (assumes keys can be compared)
* Binary trees with key/value pairs in which the keys of left descendants of a node are less than the key of the node and keys of right descendants are greater
* Efficiency (Assume the tree is close to complete)
...