Chapter 11

Sets

© 2006 Pearson Education Inc., Upper Saddle River, NJ. All rights reserved.

Overview

● Set– A collection of elements in which the same

element does not appear more than once.– Three implementations of sets: ordered lists

(11.2), Binary search trees (11.3) and Hash tables (11.4)

● 11.1: Set interface● 11.5: Java collections framework,

discussing Java's own Set interface.

The Set Interface

The Set Interface

The Set Interface

The Set Interface

11.1 The Set Interface

The Set Interface

The Set Interface

The Set Interface

The Set Interface

The Set Interface

The Set Interface

The Set Interface

● A good list of words can be found in the file /usr/share/dict/words on most Unix systems, including Mac OS X

● Efficient Set implementation is important.

The Set Interface

● Given a large words.txt file with tens or hundreds of thousands of words, the program as written takes at most a few seconds to start up.

● If we change– Words = new OrderedList<String>();

● to– Words = new BinarySearchTree<String>();

● Takes unacceptable amount of time.

11.2 Ordered Lists

● Since a Set changes size as items are added and removed, a linked structure seems in order.

● An OrderedList is like a LinkedList, except that:– The elements of an OrderedList must implement

the Comparable interfaces– The elements of an OrderedList are kept in order.– The OrderedList class implements the Set

interface. It provides the methods add(), contains(), remove(), and size().

– No duplicate elements are allowed.

Ordered Lists

● Extending LinkedList– The problem is that the LinkedList class

implements the List interface, which conflicts with the Set interface.

– The add() method from the List interface should add the argument target to the end of the list, even if it is already present.

– But the add() method from the Set interface may add target at any position, but not if it is already present.

Ordered Lists

Ordered Lists

● We should extend a class only when an instance of the subclass works in place of an instance of the superclass.

Ordered Lists

Ordered Lists

Ordered Lists

●The contains() method for the OrderedList class is a linear search (sequential search).

Ordered Lists

● To add something to a Set, we must first find where it belongs, then (if it is not present) put it there.

Ordered Lists

Ordered Lists

●To remove something, we must first find

where it belongs, then (if it is present) remove it.

● Since the final “put it there” and “remove it” operations take constant time, all three methods (search, insertion and deletion) have the same order of running time Θ(n) for a given implementation.

● The OrderedList data structure is easy to implement, but it requires linear time for search, insertion, and deletion.

Ordered Lists

11.3 Binary Search Trees

● Binary search tree– More efficient under some circumstances.

Binary Search Trees

Binary Search Trees● Search

– Successful search for node 16.

– Shaded nodes are never examined

Binary Search Trees

● Searching a binary search tree.– In a perfect tree, time complexity is Θ(log n).– In the Anagrams program when the word file is

in alphabetical order, it produces a worst case. Every new node is a right child, Θ(n).

Binary Search Trees

● There are two complications to the code:– Once we reach a null node, we have forgotten

how we got there. Since we need to modify either the left or right field in the parent (e.g. node 16) of the new leaf, we'll need this information.

– We need to deal with the situation in which the binary search tree is empty.

● Insertion (node 15)● The search fails when 16 has no child, so we add a new leaf there.

Binary Search Trees

Fig. 11-20 (p300) Both the BinaryNode and BinarySearchTree classes must be modified to implement the Parent interface.

Binary Search Trees

Fig. 11-21 (p300) The getChild() and setChild() methods for the BinaryNode class.

Binary Search Trees

Fig. 11-22 (p301) The getChild() and setChild() methods for the BinarySearchTree class. Since there is only one child (the root), the argument direction is ignored.

Binary Search Trees

Binary Search Trees

● Deletion– The challenge is to make sure the tree is still a

binary search tree when we're done with the deletion.

– Deleting a leaf, this is easy.– If the node has only one child, we just splice it

out much as we would a node in a linked list.

Binary Search Trees

● Deletion (to delete node 2): The deleted node’s child 8 becomes a child of the deleted node’s parent 13.

Binary Search Trees

● When the node we want to delete has two children (see Figure 11-25 on page 302).– We must be very careful about which node we

choose to delete so that the tree will still be a binary search tree.

– It is always safe to choose the inorder successor of the node we originally wanted to delete.

– Find a node's inorder successor by going to the right child, then going left until we hit a node with no left child.

– It can have a right child.

Binary Search Trees

● It is safe to replace the node we want to delete with its inorder successor.– It is therefore larger than anything in the left

subtree and smaller than anything else in the right subtree.

Binary Search Trees

Binary Search Trees

Binary Search Trees

● We don't need special code for the case where node is a leaf, because in this situation parent.setChild(direction, node.getRight());

● Is equivalent to:– parent.setChild(direction, null);– Because node.getRight() returns null.

Binary Search Trees

● BinarySearchTrees should not be used in the plain form explained here.

– The worst-case, running time is linear– Worst case are not uncommon.

Hash Table

● LetterCollection– a collection of letters– Since there are only 26 different letters a data

structure as complicated as an ordered list or binary search tree is not required.

● It is also handy to keep track of the total number of letters in the collection.

Hash Table

● LetterCollection containing 1 'a', 3 'd's, and 1 'y'.

Hash Table

Hash Table

Hash Table

Hash Table

Hash Table

Hash Table

● A set can be represented by an array of booleans.– This approach is called direct addressing.

● When we want to look up some element, we go directly to the appropriate place in the array.

● Direct addressing is incredibly fast.

Hash Table

● Direct addressing cannot be used for every set.– The set of possible elements might be vastly larger

than the set of elements actually stored.– A direct addressing table would be a huge wast of

space.● Hash function

– Takes an int as input and returns an array index.– f(x) = x mod 10, where x is the integer input and f(x)

is the array index.

Hash Table (p308)

● f(x) = x mod 10

Fig. 11-31: In a hash table, a hash function maps each potential element to an array index. The shaded positions do not contain set elements; in practice, some invalid value such as -1 or null is stored there.

Hash Table

● Hash table– Have all the advantages of direct addressing,

even though it works when the number of possible elements is much larger than the number of elements actually stored.

– Most of the built-in classes have a method hashCode() which takes no arguments and returns an int which can be passes to a hash function.

● This int is called the hash code.

Hash Table● hashCode() method must return the same value

for two objects which are equals()– That is if a.equals(b), then a.hashCode() ==

b.hashCode().– But if a.hashCode() == b.hashCode(), it does not

follow that a.equals(b)– Sometimes two different, non-identical objects have

the same hash code.– When storing our own classes in a hash table, we

must define both equals() and hashCode().● Hash table set methods use hashCode() to find the right

position in the table, then use equals() to verify that the item at the position is the one we're looking for.

Hash Table

● The hash function might occasionally map two different hash codes to the same index.

● For example, 37 mod 10 = 87 mod 10. This is called a collision.– We try to choose a hash function which makes

collisions rare.– No matter how good our hash function is,

collisions cannot be completely avoided.– Since there are more potential elements than

positions in the table, some elements must hash to the same location.

Hash Table (collision resolution)

1. Chaining– To keep a sequence of ListNodes (effectively an

ordered list) at each position in the table.

Hash Table (collision resolution)● To search, insert, or delete, we simply use the

hash function to find the right list and then perform the appropriate ordered list operation there.

● If we know in advance how many elements the Set contains (e.g. n), we can choose the array length to be proportional to this.– This limits the average number of elements per list

to a constant.● Average time for search, insertion, and deletion

is Θ(1) (constant time).

Hash Table (collision resolution)

2. Open addressing– Collision resolution techniques that avoid chains

and store all of the elements directly in the array.– 2.1 Linear probing

● If there is a collision during insertion, we simply move on to the next unoccupied position.

Hash Table● Three problems with linear probing:

– Tables can fill up: Fails catastrophically when there's no more room.

● Solve this problem by making the new table larger and rehashing when the table gets too full.

– We can't simply remove an item to delete it.● This affects future searches● By replacing a deleted item with a special value.

– Neither null nor equals() to any target, so searches continue past it.● The table may become full of deleted values.

– Solve by occasionally rehashing.

– Clusters tend to occur and grow.● Insertion into any position in a cluster expands the cluster.

Hash Tables

● 2.2 Double hashing– We use two hash functions

● The first function tells us where to look first, while the second one tells us how many positions to skip each time if we find an occupied one.

● Two elements which originally has to the same position are unlikely to follow the same sequence of position through the table.

– See Fig. 11-35 (p311): Double hashing● f(x) = x mod 10● g(x) = floor(x / 100) //floor function● Examples: to insert 256 and 386 into the hash table.

Hash Tables

– Reduce the risk of clustering– Linear probing is a special case of double hashing

where the second has function always returns 1.– The size of the table and the number returned by

the second hash function should be relatively prime.● Have no factor in common other than 1.● Easiest way to ensure relative primality is to make the

table size a power of two, require that the second hash function always returns an odd number

Hash Tables

Hash Tables

Hash Tables

● If this position is occupied by something other than target, we use hash2() to decide how many positions to skip ahead.

Hash Tables

Hash Tables

● If the table is at least half full (including deleteds), we rehash into a larger table before inserting.

Hash Tables

Hash Tables

Hash Tables

● There are only two drawbacks to hash tables:– Traversal is not efficient.

● Visiting all of the elements requires a search through the entire table, which is presumably mostly empty.

– This takes time proportional to the capacity of the table, not to the number of elements.

– With open addressing, deletion is a bit awkward● We have to leave behind a special value deleted and

occasionally rehash.– A hash table may not be the best Set implementation to use

in an application where many deletions are expected.

Java Collections Framework Again

● Java collections framework– In the java.util package, the interface Collection

is extended by an interface Set, which is similar to the one we defined in Section 11.1.

– The same element may appear more than once in a collection, but not in a set.

– The Set interface is extended by SortedSet.

Java Collections Framework Again

● HashSet and TreeSet– HashSet

● Is very much like the HashTable we defined in Section 11.4

– TreeSet● Is similar to the BinarySearchTree, but it uses some

advanced techniques.

Java Collections Framework Again

Java Collections Framework Again

● Maps– Each of a set of keys is associated with a value.– Each key may appear only once in a Map, although

it is possible for several keys to be associated with the same value.

– The Map interface requires the methods put() and get().

Java Collections Framework Again

● Map<String, Interger> numbers =

new TreeMap<String, Integer>();● numbers.put(“five”, 5);● numbers.put(“twelve”, 12);● numbers.put(“a dozen”, 12);

● numbers.get(“twelve”) returns the Integer 12.

Java Collections Framework Again

● Data structures for Maps are the same as those used for Sets, with a small amount of extra work needed to keep track of the values in addition to the keys.

Java Collections Framework Again

Summary

● Set interface– OrderedList

● An ordered list is a linked list in which the elements are in order.

– It should be be used only for very small sets.

– BinarySerachTree● A binary tree where all of the elements in the left subtree

are less than the root and all the elements in the right subtree are greater than the root.

– Average performance is good, it performs very poorly when the data are already sorted—a common situation.

Summary

– HashTable● Stores elements in an array, using a hash function to

determine where in the array to place each element.– Since there are more potential elements than positions in the

array, collisions can occur.– Three approaches to collision resolution are:

● Chaining● Linear probing● Double hashing

– Hash tables have extremely good performance on average.

Summary

● The java collections framework defines a Set interface, implemented by a TreeSet and HashSet.

● Map interface for associating keys with values, implemented by TreeMap and HashMap.

Summary

Chapter 11 Self-Study Homework

● Pages: 296-318● Exercises: 11.5, 11.7, 11.8, 11.9, 11.17, 11.22