Chapter 16 Review Exercise Solutions
R16.1
A set is an unordered collection that has no duplicate elements. A map is a data structure for storing key/value pairs. The keys have no duplicates, but the values may be duplicated.
R16.2
HashSet and TreeSet 
R16.3
The fundamental operations on the abstract set type are:
•	adding an element
•	removing an element
•	testing whether an element is present in the set
•	enumerating the set elements
The Set interface provides additional methods such as:
•	counting the elements
•	adding and removing multiple elements
•	testing whether multiple elements are present in the set
•	copying the elements to an array
R16.4
To compute the union, follow this process: 
1.	Add all elements from the first set to the result. 
2.	Add all elements from the second set to the result.
(This uses the elementary operations of iterating through the set elements and of adding an element to a set.) 
To compute the intersection, follow this process:
1.	For each of the elements in the first set, test if it is in the second set. If so, add it to the result.
(This uses the elementary operations of iterating through the set elements, of testing whether an element is contained in a set, and of adding an element to a set.) 
R16.5
Set<String> union = new HashSet<String>(s1);
union.addAll(s2);

Set<String> intersection = new HashSet<String>(s1);
intersection.retainAll(s2);
R16.6
A map can have two keys with the same value, but cannot have two values with the same key. 
R16.7
We can define a class Pair that will represent <key, value> pairs. Then, we can add the pairs to a set (e.g. HashSet) to implement a map. The only condition is that we have to make sure that duplicate keys cannot be inserted into the map (see R16.8). 
R16.8
You want to hash only the key, not the value. That is, hashCode(key, value) = hashCode(key). More concretely, here is a Pair class with a correct hashCode implementation. 
public class Pair
{
   private Object key;
   private Object value;
   public Pair(Object aKey, Object aValue)
   {
      key = aKey;
      value = aValue;
   }
   public Object getKey() { return key; }
   public Object getValue() { return value; }
   public int hashCode() { return aKey.hashCode() }
}
R16.9
Jim:
31 * (31 * 'J' + 'i') + 'm'
31 * (31 * 74 + 105) + 109 = 74478
Joe:
31 * (31 * 'J' + 'o') + 'e'
31 * (31 * 74 + 111) + 101 = 74656
R16.10
Using this formula:
int h = x.hashCode();
if (h < 0) h = -h;
h = h % size;
the array indexes for the strings in Table 1 can be verified by:
"Adam" = 2035631 % 101 = 77
"Eve" = 70068 % 101 = 75
"Harry" = 69496448 % 101 = 65
"Jim" = 74478 % 101 = 41
"Joe" = 74656 % 101 = 17
"Juliet" = -2065036585 % 101 = 79
"Katherine" = 2079199209 % 101 = 79
"Sue" = 83491 % 101 = 65

R16.11
A binary search tree is a binary tree. However, in a binary search tree, each subtree has the property that all descendants to the left are smaller than the value in the subtree’s root, and that all descendants to the right are larger than the subtree’s root.
Here is a binary tree that isn't a binary search tree:
        Harry
      /      \
Tom           Diana
Here is a binary tree that is a binary search tree:
        Diana
             \
            Tom
            /
         Harry
R16.12
In a balanced tree, each subtree has the property that the number of descendants to the left is approximately equal to the number of descendants to the right. In an unbalanced tree, this property does not hold.
Here is a balanced binary tree:
        Harry
      /      \
  Tom         Diana
Here is a binary tree that is not balanced:
        Diana
             \
            Tom
            /
         Harry
R16.13
	Adam

	Adam
           \
            Eve

	Adam
           \
           Eve
               \
                Romeo

	Adam
           \
            Eve
                \
                Romeo
               /      
          Juliet       

	Adam
           \
            Eve
                \
                Romeo
               /      \
          Juliet       Tom

	Adam
           \
            Eve
          /     \
     Diana       Romeo
               /      \
          Juliet       Tom

	Adam
           \
            Eve
         /      \
     Diana       Romeo
               /      \
          Juliet       Tom
         /
    Harry
R16.14
The tree is
                      Harry
                    /       \
                Diana         Tom
               /     \       /
             Adam    Eve   Juliet
                                 \
                                 Romeo
Printing this tree with the print method yields the printout
Adam
Diana
Eve
Harry
Juliet
Romeo
Tom 
That's the same printout as the printout resulting from the tree in the preceding exercise because the tree contents are always printed in sorted order, no matter in which order the nodes were inserted.
R16.15
2 7 4 1 8 5 3 9 6 10
R16.16
When removing an element from a priority queue, the element with the highest priority is retrieved. To implement a priority queue with a binary search tree is straightforward. We just need to add elements as we normally would; and, to remove an element from the priority queue, we would find the largest element in the tree (the rightmost element) and remove it. Adding, finding and removing an element are each O(log(n)) operations. Thus, adding and removing an element from a priority queue—if implemented with a binary search tree—would take O(log(n)) time. 
R16.17
None of the traversal orders (preorder, inorder, postorder) would print a heap in sorted order because the heap structure is a level-by-level structure, and not a node-by-node structure like that of a binary search tree. On a heap there is no relationship between the left branch of a node and the right branch of a node, other than the fact that both contain elements that are greater or equal than the node itself (a min-heap). For example, consider the heap: 
     85
   /     \
  90     86
 /  \   /  \
91  92 88  89

Preorder traversal: 85 90 91 92 86 88 89 
Inorder traversal: 91 90 92 85 88 86 89 
Postorder traversal: 91 92 90 88 89 86 85 
R16.18
A heap of height h has h - 1 complete levels, but the last level can have 1 to 2h - 1 elements. A complete binary tree has 2h - 1 elements. Thus, a heap has 2h - 1 elements plus the number of elements in the last level. The minimum number of elements that a heap can have is 2h - 1 and the maximum number of elements that a heap can have is 2h - 1 + 2h - 1 - 1 = 2h - 1. 
R16.19
The nodes are stored as 

   Unused | Root = n00 | Level 1 = n10 n11 | Level 2 = n20 n21 n22 n23 | . . .
   [0]      [1]          [2]                 [4]

There are 2k nodes in level k (because each complete level has twice as many nodes as its parent). 
Therefore, the kth level starts at index 1 + 1 + 2 + 4 + . . . + 2k – 1 = 2k. 
The jth node in the kth level has index i = 2k + j. 
Since it is preceded by j nodes in its level, its children are preceded by 2j nodes in the next level. That is, they are in positions 2j and 2j + 1. (Note that we count positions starting with 0.) 
Therefore, their array indexes are 2k + 1 + 2j and 2k + 1 + 2j + 1. 
Those are the same values that the child node formula produces: The left child index is 2i = 2 · (2k + j) = 2k + 1 + 2j, and the right child index is 2i + 1 = 2 ·  (2k + j) + 1 = 2k + 1 + 2j + 1. 
The formula for the parent index follows immediately. If the child of the parent with index p has index i = 2p or i = 2p + 1, then clearly p = i / 2, where / denotes integer division.
R16.20
Start calling fixHeap with the parent of the last node, then move to the root 

11 | 27 8 | 14 45 6 24 | 81 29 33
               --

11 | 27 8 | 14 45 6 24 | 81 29 33
            --
    
11 | 27 8 | 81 45 6 24 | 14 29 33
        -

11 | 27 24 | 81 45 6 8 | 14 29 33
     --

11 | 81 24 | 29 45 6 8 | 14 27 33
--

81 | 45 24 | 29 33 6 8 | 14 27 11

Now keep swapping the root with the last unsorted element, and call fixHeap after each swap. 

45 | 33 24 | 29 11 6 8 | 14 27 / 81
33 | 29 24 | 27 11 6 8 | 14 / 45 81
29 | 27 24 | 14 11 6 8 / 33 45 81
27 | 14 24 | 8 11 6 / 29 33 45 81
24 | 14 6 | 8 11 / 27 29 33 45 81
14 | 11 6 | 8 / 24 27 29 33 45 81
11 | 8 6 / 14 24 27 29 33 45 81
8 | 6 / 11 14 24 27 29 33 45 81
6 / 8 11 14 24 27 29 33 45 81