1A. In a hash map every item must be examined to find the minimum since
there's no ordering among the elements in the hash table.

In a tree, the minimum element is the left-most leaf, since the tree is
balanced this can be found in O(log n), or it can be found in O(1) if a
pointer to it is kept and re-balancing is O(log n) as well.

B. 

As trees below:                      As arrays below
   20                                 20


   20        15
  15     -> 20                        15 20  

  15         7
 20 7  ->  20 15                      7 20 15

   7
 20  15                               7 20 15 25
25

   7                7
 20  15  -->     13   15              7 13 15 25 20
25 13          25  20

C.

Height is O(n) since its recurrence is T(n) = 2T(n/2) + O(1) in
average case and T(n) = T(n-1) + O(1) in worst case, which is all
O(n) 

For deepLeaf the average case is

T(n) = T(n/2) + O(n) which is O(n)

for worst-case we get

T(n) = T(n-1) + O(n) which is O(n^2)

2A

lemon cherry apple guava papaya orange tangerine watermelon

2B

apple guava cherry orange watermelon tangerine papaya lemon

2C

banana is right child of apple
persimmon is left child of tangerine


2D

list.add(t.info);
leafPathPrintAux(t.left,list);
leafPathPrintAux(t.right,list);
list.remove(list.size()-1);


3a.  Items in same chain have same hashCode() % 1003

3b. If guaranteed performance is required, or number of buckets
is small, search tree might be warranted. but if chains are small
linked-list will win in performance, e.g., removal is O(1) once
found rather than O(log n) and simpler to codee

3c.

Avoid empty buckets

3d.

get is unchanged by linked list, still O(1)
put is O(1) add to end of linked list as well as bucket
remove is O(n) since predecessor must be found to link-around
and in worst case this is O(n) for singly linked list but O(1)
for doubly linked

4. Bubble sort uses little memory and is simple to code. If data
is already nearly sorted its fast. For small data, it's a win.

For big data, O(n log n) will always be better even if more memory
is required.

5A. Comment out line

  if (list.contains(value)) return false;

5B.

add line

  if (find(word,index+1,row,col,board,list)) return true;