Solution Manual for Data Structures and Algorithms in Java 6th edition by Michael T. Goodrich

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

1

Java Primer

Hints and Solutions Reinforcement R-1.1) Hint Use the code templates provided in the Simple Input and Output section.

R-1.2) Hint You may read about cloning in Section 3.6.

R-1.2) Solution Since, after the clone, A[4] and B[4] are both pointing to the same GameEntry object, B[4].score is now 550.

R-1.3) Hint The modulus operator could be useful here.

R-1.3) Solution public boolean isMultiple(long n, long m) { return (n%m == 0); } R-1.4) Hint Use bit operations.

R-1.4) Solution public boolean isEven(int i) { return (i & 1 == 0); } R-1.5) Hint The easy solution uses a loop, but there is also a formula for this, which is discussed in Chapter 4.

R-1.5) Solution public int sumToN(int n) { int total = 0; for (int j=1; j <= n; j++) total += j; return total; }

Chapter 1. Java Primer

2

R-1.6) Hint The easy thing to do is to write a loop.

R-1.6) Solution public int sumOdd(int n) { int total = 0; for (int j=1; j <= n; j += 2) total += j; return total; } R-1.7) Hint The easy thing to do is to write a loop.

R-1.7) Solution public int sumSquares(int n) { int total = 0; for (int j=1; j <= n; j++) total += j∗j; return total; } R-1.8) Hint You might use a switch statement.

R-1.8) Solution public int numVowels(String text) { int total = 0; for (int j=0; j < text.length( ); j++) { switch (text.charAt(j)) { case 'a': case 'A': case 'e': case 'E': case 'i': case 'I': case 'o': case 'O': case 'u': case 'U': total += 1; } } return total; } R-1.9) Hint Consider each character one at a time.

3 R-1.10) Hint Consider using get and set methods for accessing and modifying the values.

R-1.11) Hint The traditional way to do this is to use setFoo methods, where Foo is the value to be modified.

R-1.11) Solution public void setLimit(int lim) { limit = lim; } R-1.12) Hint Use a conditional statement.

R-1.12) Solution public void makePayment(double amount) { if (amount > 0) balance −= amount; } R-1.13) Hint Try to make wallet[1] go over its limit.

R-1.13) Solution for (int val=1; val <= 58; val++) { wallet[0].charge(3∗val); wallet[1].charge(2∗val); wallet[2].charge(val); } This change will cause wallet[1] to attempt to go over its limit.

Creativity C-1.14) Hint The Java method does not need to be passed the value of n as an argument.

C-1.15) Hint Note that the Java program has a lot more syntax requirements.

C-1.16) Hint Create an enum type of all operators, including =, and use an array of these types in a switch statement nested inside for-loops to try all possibilities.

C-1.17) Hint Note that at least one of the numbers in the pair must be even.

C-1.17) Solution

Chapter 1. Java Primer

4 public boolean hasEvenPair(int[ ] data) { if (data.length > 1) { for (int j=0; j < data.length; j++) if (data[j] % 2 == 0) return true; } return false; }

C-1.18) Hint Use the Math.pow function for calculations. Use your solution for norm(v,p) to implement norm(v).

C-1.18) Solution public double norm(double[ ] v, int p) { int total = 0; for (double k : v) total += Math.pow(k,p); double exp = 1.0/p; return Math.pow(total, exp); } public double norm(double[ ] v) { return norm(v,2); } C-1.19) Hint This is the same as the logarithm, but you can use recursion here rather than calling the log function.

C-1.20) Hint The simple solution just checks each number against every other one, but we will discuss better solutions later in the book. Make sure you don’t compare a number to itself.

C-1.20) Solution public boolean distinct(float[ ] data) { for (int j=0; j < data.length − 1; j++) for (int k=j+1; k < data.length; k++) if (data[j] == data[k]) return false; return true; } C-1.21) Hint Consider using swaps to reshuffle the array one entry at a time, starting from the beginning and moving to the end.

C-1.22) Hint There are many solutions. If you know about recursion, the easiest solution uses this technique. Otherwise, consider using an array to

5 hold solutions. If this still seems to hard, then consider using six nested loops (but avoid repeating characters and make sure you allow all string lengths).

C-1.22) Solution Here is a possible solution: public static void permute(ArrayList bag, ArrayList permutation) { // When the bag is empty, a full permutation exists if (bag.isEmpty( ) ) { System.out.println(permutation); } else { // For each element left in the bag for(int i = 0; i < bag.size( ); i++) { // Take the element out of the bag // and put it at the end of the permutation Object obj = bag.get(i); bag.remove(i); permutation.add(obj); // Permute the rest of the bag (recursively) permute(bag, permutation); // Take the element off the permutation // and put it back in the bag permutation.remove(permutation.size( ) − 1); bag.add(i, obj); } } } public static void main(String[ ] args) { ArrayList<Character> orig = new ArrayList<>( ); char[ ] word = {'c', 'a', 't', 'd', 'o', 'g'}; for (char c : word) orig.add(c); permute(orig, new ArrayList( )); } C-1.23) Hint Go back to the definition of dot product and write a for loop that matches it.

C-1.23) Solution

Chapter 1. Java Primer

6

public int[ ] compute(int[ ] a, int[ ] b) { if (a.length != b.length) throw new IllegalArgumentException("arrays must have same length") int[ ] c = new int[a.length]; for (int j=0; j < a.length; j++) c[j] = a[j] ∗ b[j]; return c; } C-1.24) Hint The card is no longer needed as an explicit parameter.

C-1.24) Solution public void printSummary( ) { System.out.println("Customer = " + customer); System.out.println("Bank = " + bank); System.out.println("Account = " + account); System.out.println("Balance = " + balance); System.out.println("Limit = " + limit); } C-1.25) Hint You might use a StringBuilder to compose the pieces of the string into one large string (including newlines).

C-1.25) Solution public String toString( ) { StringBuilder sb = new StringBuilder( ); sb.append("Customer = " + customer + System.lineSeparator( )); sb.append("Bank = " + bank + System.lineSeparator( )); sb.append("Account = " + account + System.lineSeparator( )); sb.append("Balance = " + balance + System.lineSeparator( )); sb.append("Limit = " + limit + System.lineSeparator( )); return sb.toString( ); }

Projects P-1.26) Hint Use an array to buffer all the original lines.

P-1.27) Hint You do not need to use a graphical user interface, but you may want to use the System.console() method.

P-1.28) Hint Define a way of indexing all the sentences and the location in each one and then work out a way of picking eight of these locations for a typo.

7 P-1.29) Hint Use a two-dimensional array to keep track of the statistics and a one-dimensional array for each experiment.

P-1.30) Hint We recommend using the Java Swing package.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

2

Object-Oriented Design

Hints and Solutions Reinforcement R-2.1) Hint Think of applications that could cause a death if a computer failed.

R-2.1) Solution Air traffic control software, computer integrated surgery applications, and flight navigation systems.

R-2.2) Hint Consider an application that is expected to change over time, because of changing economics, politics, or technology.

R-2.3) Hint Consider the File or Window menus.

R-2.4) Hint You can make the change and test the code.

R-2.4) Solution The problem is that when a $5 penalty is assessed, presumably because of an attempt to go over the credit limit, the call charge(5) recursively invokes the PredatoryCreditCard.charge method; since that fee could again be an attempt at violating the credit limit, it too may fail, leading to an infinite recursion.

R-2.5) Hint You can make the change and test the code.

R-2.5) Solution The goal is to assess a $5 charge as a penalty, yet that charge may be refused by the call to super.charge(5) if the user is already at or near the credit limit.

R-2.6) Hint Your program should output 42, which Douglas Adams considers to be the answer to the ultimate question of life, universe, and everything.

R-2.6) Solution public static void main(String[ ] args) { FibonacciProgression fp = new FibonacciProgression(2,2); for (int j=0; j < 7; j++) fp.nextValue( ); // ignore the first 7 values System.out.println(fp.nextValue( )); }

9 R-2.7) Hint A long value can be no larger than 263 − 1.

R-2.7) Solution 256 calls to nextValue will end on the value 263 . Since the maximum positive value of a long is 263 − 1, 256 − 1 calls to nextValue can be made before a long-integer overflow.

R-2.8) Hint Code up an example and see what the compiler says.

R-2.9) Hint Think about what happens when a new instance of class Z is created and when methods of class Z are called.

R-2.9) Solution There are two immediate inefficiencies: (1) the chaining of constructors implies a potentially long set of method calls any time an instance of a deep class, Z, is created, and (2) the dynamic dispatch algorithm for determining which version of a certain method to use could end up looking through a large number of classes before it finds the right one to use.

R-2.10) Hint Think about code reuse.

R-2.10) Solution Whenever a large number of classes all extend from a single class, it is likely that you are missing out on potential code reuse from similar methods in different classes. There is likely some factoring of methods into common classes that could be done in this case, which would save programmer time and maintenance time, by eliminating duplicated code.

R-2.11) Hint Review the section about casting in an inheritance hierarchy, and recall that an object behaves according to what it actually is, not what it is called.

R-2.11) Solution Read it.

Ship it.

Buy it.

Read it.

Box it.

Read it.

R-2.12) Hint Review the definition of inheritance diagram, and begin your drawing with Object as the highest box.

R-2.13) Hint Casting in an inheritance relationship can only move up or down the hierarchy.

R-2.13) Solution No, d is referring to a Equestrian object that is not not also of type Racer. Casting in an inheritance relationship can only move up or down the hierarchy, not “sideways.”

R-2.14) Hint You don’t need to declare the array, just show how to use an exception try-catch block to reference it.

Chapter 2. Object-Oriented Design

10 R-2.14) Solution

try { System.out.println(array[i]); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index " + e.getMessage( ) + " out of bounds."); }

R-2.15) Hint Reread the section on throwing exceptions.

R-2.15) Solution public void makePayment(double amount) { if (amount < 0) throw new IllegalArgumentException("Amount must be nonnegative"); balance −= amount; }

Creativity C-2.16) Hint Create a separate class for each major behavior.

C-2.17) Hint Try to use variables and conditions that are impossible, but the dependence on their values requires logical reasoning that the compiler writers did not build into their compiler.

C-2.18) Hint You will need to maintain some additional state information.

C-2.18) Solution

11 private int chargesThisMonth = 0; public void processMonth( ) { chargesThisMonth = 0; ... } public boolean charge(double price) { boolean isSuccess = super.charge(price); if (!isSuccess) balance += 5; chargesThisMonth++; if (chargesThisMonth > 10) balance += 1; return isSuccess; }

// new instance variable

// reset

// call inherited method // assess a $5 penalty

// assess a $1 fee

C-2.19) Hint Keep track of how much has been paid during the current month.

C-2.20) Hint Don’t forget you can use getBalance( ) as well.

C-2.20) Solution public void processMonth( ) { if (getBalance( ) > 0) { double monthlyFactor = Math.pow(1 + apr, 1.0/12); setBalance(monthlyFactor ∗ getBalance( )); } }

C-2.21) Hint You need to use the super keyword in B and C. C-2.21) Solution

12

Chapter 2. Object-Oriented Design public class A { int x = 1; public void setIt(int y) { x = y; } public int getIt( ) { return x; } } public class B extends A { int x = 2; public void setIt (int y) { x = y; } public int getIt( ) { return x; } public void superSetIt (int y) { super.x = y; } public int superGetIt( ) { return super.x; } } public class C extends B { int x = 3; public void setIt (int y) { x = y; } public int getIt( ) { return x; } public void superSetIt (int y) { super.x = y; } public int superGetIt( ) { return super.x; } public void superDuperSetIt(int y) { super.superSetIt(y); } public int superDuperGetIt( ) { return super.superGetIt( ); } public static void main(String[ ] args) { C c = new C( ); System.out.println("C's is " + c.getIt( )); System.out.println("B's is " + c.superGetIt( )); System.out.println("A's is " + c.superDuperGetIt( )); c.superDuperSetIt(4); System.out.println("C's is " + c.getIt( )); System.out.println("B's is " + c.superGetIt( )); System.out.println("A's is " + c.superDuperGetIt( )); } } C-2.22) Hint Recall the rule about inheritance in Java.

C-2.22) Solution Inheritance in Java allows specialized classes to be built from generic classes. Because of this progression from generic to specialized in the class hierarchy, there can never be a circular pattern of inheritance. In other words, there cannot be a superclass A and derived classes B and C such that B extends A, then C extends B, and finally A extends C. Such a cycle is impossible because A is the generic superclass from which C is eventually extended, thus it is impossible from A to extend C,

13 for this would mean A is extending itself. Therefore, there can never occur a circular relationship which would cause an infinite loop in the dynamic dispatch.

C-2.23) Hint Can you determine a missing entry of a Fibonacci sequence if you are given the number immediate before it and after it?

C-2.23) Solution protected void advance( ) { current += prev; prev = current − prev; } C-2.24) Hint Use the code from the website as a starting point.

C-2.24) Solution public class AbsoluteProgression extends Progression { protected long prev; public AbsoluteProgression( ) { this(2,200); } public AbsoluteProgression(long first, long second) { super(first); // as second = Math.abs(first-prev) prev = first−second; } protected void advance( ) { long next = Math.abs(current−prev); prev = current; current = next; } } C-2.25) Hint Replace each use of type long with the generic parameter type T. C-2.26) Hint Use the sqrt method in the java.lang.Math class.

C-2.27) Hint Go to the java.com website to review the BigInteger class.

C-2.28) Hint Use three different classes, for each of the actors, and provide methods that perform their various tasks, as well as a simulator engine that performs the periodic operations.

C-2.29) Hint If you have not had calculus, you can look up the formula for the first derivative of a polynomial on the Internet.

Chapter 2. Object-Oriented Design

14

Projects P-2.30) Hint You don’t have to use GUI constructs; simple text output is sufficient, say, using X’s to indicate the values to print for each bar (and printing them sideways).

P-2.31) Hint When a fish dies, set its array cell back to null.

P-2.32) Hint Use random number generation for the strength field.

P-2.33) Hint Create a separate class for each major behavior. Find the available books on the Internet, but be sure they have expired copyrights.

P-2.34) Hint Lookup the formulas for area and perimeter on the Internet.

P-2.35) Hint You need some way of telling when you have seen the same word you have before. Feel free to just search through your array of words to do this here.

P-2.36) Hint While not always optimal, you can design your algorithm so that it always returns the largest coin possible until the value of the change is met.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

3

Fundamental Data Structures

Hints and Solutions Reinforcement R-3.1) Hint Use a calculator to aid in the arithmetic.

R-3.2) Hint You have to have your random number select a random index in the array, so be sure to keep track of the number, n, of entries in the array and do not index past index n − 1.

R-3.3) Hint The alphabets for most alphabet-based languages are included in the Unicode character encoding standard.

R-3.3) Solution The alpha array and the various uses of value 26 would have be changed to the new alphabet and its size. In addition, all the places that use the literal A to refer to the first letter would now have to be changed to the first letter in the new alphabet. In this case, it would be better to define a final static int FIRSTLETTER, set it to the first letter, and use it instead of A. This assumes the messages are still in upper-case, of course.

R-3.4) Hint You may want to add a new instance variable to track if the game has been completed.

R-3.5) Hint Make the modification in the code and test it.

R-3.5) Solution There are no negative consequences if removing those lines (in fact there would be an every so slight increase in efficiency without). While the internal state may seem inconsistent with tail referencing a defunct node, that tail reference is never accessed for an empty list, so the inconsistency has no effect.

R-3.6) Hint It is okay to have an algorithm running in linear time.

R-3.6) Solution

16

Chapter 3. Fundamental Data Structures private Node<E> penultimate( ) { if (size < 2) throw new IllegalStateException("list must have 2 or more entries"); Node<E> walk = head; while (walk−>next−>next != null) walk = walk−>next; return walk; } R-3.7) Hint There exists a one-line solution.

R-3.7) Solution tail.setNext(new Node<>(e, tail.getNext( ))) R-3.8) Hint Consider a combined search from both ends. Also, recall that a link hop is an assignment of the form ”p = p.getNext( );” or ”p = p.getPrev( );”.

R-3.8) Solution The following method runs in O(n) time. private Node<E> middle( ) { if (size == 0) throw new IllegalStateException("list must be nonempty"); Node<E> middle = header−>next Node<E> partner = trailer−>prev; while (middle != partner && middle−>next != partner) { middle = middle.getNext( ); partner = partner.getPrev( ); } return middle; } R-3.9) Hint Use a loop to traverse the list while counting.

R-3.9) Solution public int size( ) { int count=0; Node<E> walk = head; while (walk != null) { count++; walk = walk.getNext( ); } return count; } R-3.10) Hint You need to keep track of where you start or your method will have an infinite loop.

17 R-3.10) Solution public int size( ) { if (tail == null) return 0; Node<E> walk = tail−>next; int count=1; while (walk != tail) { count++; walk = walk.getNext( ); } return count; } R-3.11) Hint Do not include the sentinels in the count.

R-3.11) Solution public int size( ) { int count=0; Node<E> walk = header−>next; while (walk != trailer) { count++; walk = walk.getNext( ); } return count; } R-3.12) Hint Carefully relink existing nodes.

R-3.13) Hint Recall that a two-dimensional array in Java is really a onedimensional array such that each entry is itself a reference to a one-dimensional array.

R-3.14) Hint Recall the ways for doing array copying in the java.util.Arrays class.

R-3.14) Solution It seems a stretch to come up with three meaningful ways, but technically each of the following will suffice: backup = original.clone( ); backup = java.util.Arrays.copyOf(original, backup.length); backup = java.util.Arrays.copyOfRange(original, 0, backup.length); R-3.15) Hint You can rely on the size variable to walk the correct number of steps when traversing the lists.

R-3.16) Hint The sentinels are irrelevant to the equivalence of two lists.

Chapter 3. Fundamental Data Structures

18

Creativity C-3.17) Hint You don’t need to sort A. C-3.17) Solution public int missing(int[ ] A) { boolean[ ] found = new boolean[A.length]; // false, by default for (int val : A) found[val] = true; for (int k=1; k < found.length; k++) if (!found[k]) return k; return −1; // shouldn't happen if input as expected } C-3.18) Hint It might help to sort B. C-3.18) Solution Sort the array B then scan it from front to end looking for the repeated entries. Each pair of repeated integers will be consecutive in the sorted listing.

C-3.19) Hint Add items at the “end” of the contiguous run of objects in the array. For removing an object, consider first swapping it with the object at index n − 1.

C-3.19) Solution public void add(GameEntry e) { if (numEntries < board.length) { board[numEntries] = e; numEntries++; } // otherwise no room for new entry } public GameEntry remove(int i) throws IndexOutOfBoundsException { if (i < 0 | | i >= numEntries) throw new IndexOutOfBoundsException("Invalid index: `` + i); GameEntry temp = board[i]; if (i != numEntries - 1) board[i] = board[numEntries - 1]; board[numEntries-1] = null; numEntries--; return temp; } C-3.20) Hint Imagine what would happen if a = 1.

19 C-3.21) Hint Recall the definition of the java.util.nextInt method and note that one of the values returned has a special property with respect to multiplication.

C-3.21) Solution The product will be 0 with probability 1 − 0.9100 , which is much larger than 0.99, since the only way the product will not be zero is if no element of A is zero.

C-3.22) Hint Randomly choose the first element, then the second, and so on.

C-3.23) Hint You might want to consider using a two-dimensional array.

C-3.23) Solution Define an (n + 1) × (n + 1) two-dimensional boolean array M, which will record the meeting pairs. So that M[i, j] = true if and only if player i and j have meet. In addition, define a one-dimensional integer array c of size n + 1 so that c[i] is a count of the number of other players that player i has met. When a player i and j meet, we check M[i, j], and if it is true, then we are done—the players have already met.

Otherwise, we set M[i, j] and M[ j, i] to true and we increment c[i] and c[ j]. If either c[i] or c[ j] equals n − 1 after this, then we have a winner.

C-3.24) Hint The entries A[i][ j][k] and B[i][ j][k] are the ones that need to be added.

C-3.25) Hint This concatenation operation need not search all of L and M. C-3.25) Solution Simply use a temporary node to walk to the end of list L. Then, make the last element of L point to the first element of M as its “next” node.

Concatenate(L, M) Create a new node v v = L.getHead( ) while v! = null do v = v.getNext( ) v.setNext(M.getHead( )) L′ = L The number of steps is proportional to the size of L. C-3.26) Hint Splice the end of L into the beginning of M. C-3.26) Solution Use two temporary Node elements, temp1 and temp2.

Initialize temp1 to be the trailer node of L and temp2 to be the header node of M. Make the element of temp1 have its next field point to temp2 and set the element of temp2 to have its prev field point to temp1. Set L′ to be L and then set the trailer node of L′ to be the trailer node of M. C-3.27) Hint Performing the swap for a singly linked list will take longer than for a doubly linked list.

Chapter 3. Fundamental Data Structures

20

C-3.27) Solution Implementing a precise solution takes great care, especially when x and y neighbor each other. However, the issue regarding efficiency is that for swapping x and y in a singly-linked, we must locate the nodes immediately preceding x and y, and we have no quick way to do so.

C-3.28) Hint Consider changing the orientation of links while making a single pass through the list.

C-3.28) Solution Such a method of the SinglyLinkedList class could be implemented as follows. public void reverse( ) { Node<E> prev = null; Node<E> walk = head; while (walk != null) { Node<E> adv = walk.getNext( ); walk.setNext(prev); prev = walk; walk = adv; } head = prev; } Note well that the above implementation works, even for trivial lists.

C-3.29) Hint Try to find a matching alignment for the first node of one list.

C-3.30) Hint You are going to have to keep two cursors and count around L. C-3.31) Hint Adjust the constructor to properly initialize the sentinel.

C-3.32) Hint Blend techniques seen in the existing CircularlyLinkedList and DoublyLinkedList.

C-3.33) Hint You will need to add a prev reference to the node, and maintain it properly whenever the list changes.

C-3.34) Hint Make sure to properly link the new chain of nodes.

C-3.35) Hint Make sure to create new sentinel nodes.

Projects P-3.36) Hint Matrix addition is defined so that if C = A + B, then C[i, j] = A[i, j] + B[i, j]. Matrix multiplication is defined so that if C = AB, where A is a c × d matrix and B is a d × e matrix, then C[i, j] = ∑dk=0 A[i, k]B[k, j].

That is, C is a c × e matrix.

21 P-3.37) Hint You should keep track of the number of game entries explicitly.

P-3.38) Hint You should keep track of the number of game entries explicitly.

P-3.39) Hint You will probably need separate encrypt and decrypt arrays for the upper- and lower-case characters.

P-3.40) Hint The original CaesarCipher implementation was already effectively a substitution cipher, with a specifically chosen encoder pattern.

P-3.41) Hint If you get the constructor to use the correct encoder string, everything else should work.

P-3.42) Hint A good way to generate a random encryption array is to start with the alphabet array. Then for each letter in this array, randomly swap it with some other letter in the array.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

4

Algorithm Analysis

Hints and Solutions Reinforcement R-4.1) Hint Use powers of two as your values for n.

R-4.2) Hint Set the running times equal, use algebra to simplify the equation, and then various powers of two to home in on the right answer.

R-4.2) Solution Setting the two equations equal and simplifying, we see that the cross-over occurs at n = 4 log n. Now, we can confirm that the cross-over occurs at n = 24 = 16.

R-4.3) Hint Set both formulas equal to each other to determine this.

R-4.3) Solution Setting the two sides equal and simplifying confirms that the cross-over occurs at n = 20. That is, 40n2 ≤ 2n3 for n ≥ 20.

R-4.4) Hint Any growing function will have a “flatter” curve on a log-log scale than it has on a standard scale.

R-4.4) Solution The constant function.

R-4.5) Hint Think of another way to write log nc .

R-4.5) Solution It is because log nc = c log n.

R-4.6) Hint Characterize this in terms of the sum of all integers from 1 to n.

R-4.6) Solution If this sum is E(n), then it is clearly equal to 2S(n), where S(n) is the sum of all integers from 1 to n; hence, E(n) = n(n + 1).

R-4.7) Hint Use the fact that if a < b and b < c, then a < c.

R-4.7) Solution If c f (n) is an upper bound on the running time, for some constant c, for all inputs, then this must also be an upper bound on the worst-case time.

R-4.8) Hint Simplify the expressions, and then use the ordering of the seven important algorithm-analysis functions to order this set.

R-4.8) Solution 210 , 2log n , 3n + 100 log n, 4n, n log n, 4n log n + 2n, n2 + 10n, n3 , 2n

18

Chapter 4. Algorithm Analysis R-4.9) Hint Consider the number of times the loop is executed and how many primitive operations occur in each iteration.

R-4.9) Solution The example1 method runs in O(n) time.

R-4.10) Hint Consider the number of times the loop is executed and how many primitive operations occur in each iteration.

R-4.10) Solution The example2 method runs in O(n) time.

R-4.11) Hint Consider the number of times the inner loop is executed and how many primitive operations occur in each iteration, and then do the same for the outer loop.

R-4.11) Solution The example3 method runs in O(n2 ) time.

R-4.12) Hint Consider the number of times the inner loop is executed and how many primitive operations occur in each iteration, and then do the same for the outer loop.

R-4.12) Solution The example4 method runs in O(n) time.

R-4.13) Hint Consider the number of times the inner loop is executed and how many primitive operations occur in each iteration, and then do the same for the two outer loops.

R-4.13) Solution The example5 method runs in O(n3 ) time.

R-4.14) Hint Review the definition of big-Oh and use the constant from this definition.

R-4.14) Solution There are constants c and n0 such that d(n) ≤ c f (n) for n ≥ n0 . Thus, ad(n) ≤ ac f (n) for n ≥ n0 .

R-4.15) Hint Start with the product and then apply the definition of the big-Oh for d(n) and then e(n).

R-4.15) Solution We have, by definition that d(n) ≤ c1 f (n) for n ≥ n1 , and e(n) ≤ c2 g(n) for n ≥ n2 . Thus, for n ≥ max{n1 , n2 }, d(n)e(n) ≤ c1 f (n)e(n) ≤ c1 c2 f (n)g(n).

R-4.16) Hint Use the definition of the big-Oh and add the constants (but be sure to use the right n0 ).

R-4.17) Hint You need to give a counterexample. Try the case when d(n) and e(n) are both O(n) and be specific.

R-4.18) Hint Use the definition of the big-Oh first to d(n) and then to f (n) (but be sure to use the right n0 ).

R-4.19) Hint First show that the max is always less than the sum.

R-4.20) Hint Simply review the definitions of big-Oh and big-Omega.

This one is easy.

R-4.21) Hint Recall that log nk = k log n.

19 R-4.22) Hint Notice that (n + 1) ≤ 2n for n ≥ 1.

R-4.22) Solution By the definition of big-Oh, we need to find a real constant c > 0 and an integer constant n0 ≥ 1 such that (n + 1)5 ≤ c(n5 ) for every integer n ≥ n0 . Since (n + 1) ≤ 2n for n ≥ 1, we have that (n + 1)5 ≤ (2n)5 = 32n5 = c(n5 ) for c = 32 and n ≥ n0 = 1.

R-4.23) Hint 2n+1 = 2 · 2n .

R-4.23) Solution By the definition of big-Oh, we need to find a real constant c > 0 and an integer constant n0 ≥ 1 such that 2n+1 ≤ c(2n ) for n ≥ n0 . One possible solution is choosing c = 2 and n0 = 1, since 2n+1 = 2 · 2n .

R-4.24) Hint Make sure you don’t get caught by the fact that log 1 = 0.

R-4.24) Solution n ≤ n log n for n ≥ 2 (but this is not true for n = 1).

R-4.25) Hint Use the definition of big-Omega, but don’t get caught by the fact that log 1 = 0.

R-4.26) Hint Use the definition of big-Omega, but don’t get caught by the fact that log 1 = 0.

R-4.26) Solution By the definition of big-Omega, we need to find a real constant c > 0 and an integer constant n0 ≥ 1 such that n log n ≥ cn for n ≥ n0 . Choosing c = 1 and n0 = 2, shows n log n ≥ cn for n ≥ n0 , since log n >≥ 1 in this range.

R-4.27) Hint If f (n) is a positive nondecreasing function that is always greater than 1, then ⌈ f (n)⌉ ≤ f (n) + 1.

R-4.28) Hint You can do all rows except for n log n just by setting the function equal to the value and solving for n. For the n log n function, the easiest technique is unfortunately to simply use trial-and-error on a calculator.

R-4.28) Solution The numbers in the first row are quite large. The table below calculates it approximately in powers of 10. People might also choose to use powers of 2. Being close to the answer is enough for the big numbers (within a few factors of 10 from the answers shown).

1 Second 6

1 Hour 9

1 Month 9

1 Century 12

12

15

15

log n

210 ≈ 10300000

23.6×10 ≈ 1010

22.6×10 ≈ 100.8×10

23.1×10 ≈ 1010

n

106

3.6 × 109

≈ 2.6 × 1012

≈ 3.12 × 1015

n log n

≈ 105

≈ 109

≈ 101 1

≈ 1014

n2

1000

6 × 104

≈ 1.6 × 106

≈ 5.6 × 107

n3

100

≈ 1500

≈ 14000

≈ 1500000

2n

19

31

41

51

Chapter 4. Algorithm Analysis

20

R-4.29) Hint The O(log n) calculation is performed n times.

R-4.30) Hint The O(n) calculation is performed log n times.

R-4.31) Hint Consider the cases when all entries of X are even or odd.

R-4.32) Hint First characterize the running time of Algorithm D using a summation.

R-4.32) Solution The running time of Algorithm D is proportional to ∑ni=1 i, which is O(n2 ).

R-4.33) Hint Discuss how the definition of the big-Oh fits into Al’s claim.

R-4.33) Solution To say that Al’s algorithm is “big-Oh” of Bill’s algorithm implies that Al’s algorithm will run faster than Bill’s for all input greater than some nonzero positive integer n0 . In this case, n0 = 100.

R-4.34) Hint Recall the definition of the Harmonic number, Hn .

Creativity C-4.35) Hint Use sorting as a subroutine.

C-4.35) Solution Assuming we have all three sets stored in arrays, combine all three arrays into one array. Next, sort this combined array and look to see if any element is repeated three times. If so, the three original sets are not disjoint.

C-4.36) Hint Note that 10 is a constant!

C-4.36) Solution Since 10 is a constant, we can solve this problem for any size array in O(n) time. We can begin by looping to find the largest element, and then record the index of that element in an auxiliary array of size 10. Then we find the next largest element with another loop, making sure to ignore the previously found element, and recording the index of the second largest element. Each such loop requires O(n) time; the time to check if an index has already been used can be done in O(1) time as there are O(1) entries in the auxiliary array. Therefore the overall time is O(10 · n) which is O(n).

C-4.37) Hint Think of a function that grows and shrinks at the same time without bound.

C-4.37) Solution One possible solution is f (n) = n2 · (1 + sin(n)).

C-4.38) Hint Use induction, a visual proof, or bound the sum by an integral.

C-4.38) Solution n

∑ i2 < i=1

Z n+1 0

x2 dx <

(n + 1)3 = O(n3 ) 3

21 C-4.39) Hint Try to bound this sum term by term with a geometric progression.

C-4.39) Solution Let S = ∑ni=1 i/2i < 2. Note that S = ∑ni=1 1/2i +

n−1 ∑ni=2 (i − 1)/2i = ∑ni=1 1/2i + ∑i=1 i/2i+1 < 1 + 2S . Since S < 1 + S2 , S 2 < 1 and thus S < 2.

C-4.40) Hint Recall the formula for the sum of the terms of a geometric progression.

C-4.41) Hint Use the log identity that translates log bx to a logarithm in base 2.

C-4.41) Solution logb f (n) = log f (n)/ log b, but 1/ log b is a constant.

C-4.42) Hint First, construct a group of candidate minimums and a group of candidate maximums.

C-4.42) Solution Pair up all the items and compare them, producing a set of candidate minima and candidate maxima. Now with n/2 − 1 comparisons we can find the minimum of the minima and the maximum of the maxima. The total number of comparisons is 3n/2 − 2.

C-4.43) Hint Consider the sum of the maximum number of visits each friend can make without visiting his/her maximum number of times.

C-4.43) Solution The number is one more than the total number of visits each friend can make while still being able to make one more allowed visit, that is, the sum where each friend i visits i − 1 times. In other words, the the minimum value for C such that Bob should know that one of his friends has visited his/her maximum allowed number of times is n(n − 1)/2 + 1.

C-4.44) Hint You need to line up the columns a little differently.

C-4.45) Hint Consider computing a function of the integers in A that will immediately identify which one is missing. n−1 C-4.45) Solution First calculate the sum ∑i=1 = n(n−1) 2 . Then calculate the sum of all values in the array A. The missing element is the difference between these two numbers.

C-4.46) Hint Some informal discussion of the algorithm efficiency was given at the conclusion of Section 3.1.2.

C-4.47) Hint Characterize the number of bits needed first.

C-4.47) Solution Since r is represented with 100 bits, any candidate p that the eavesdropper might use to try to divide r uses also at most 100 bits.

Thus, this very naive algorithm requires 2100 divisions, which would take about 280 seconds, or at least 255 years. Even if the eavesdropper uses the fact that a candidate p need not ever be more than 50 bits, the problem is still difficult. For in this case, 250 divisions would take about 230 seconds, or about 34 years.

Chapter 4. Algorithm Analysis

22

Since each division takes time O(n) and there are 24n total divisions, the asymptotic running time is O(n · 24n ).

C-4.48) Hint Consider the first induction step.

C-4.48) Solution The induction assumes that the set of n − 1 sheep without a and the set of n− 1 sheep without b have a sheep in common. Clearly this is not true for n = 2 sheep. If a base case of 2 sheep could be shown, then the induction would be valid.

C-4.49) Hint Look carefully at the definition of big-Oh and rewrite the induction hypothesis in terms of this definition.

C-4.50) Hint Use the definition of big-Omega, and make n = 1 and n = 2 your base cases.

C-4.51) Hint Consider the contribution made by one line.

C-4.52) Hint Try to bound from above each term in this summation.

C-4.52) Solution n

n

∑ log2 i ≤ ∑ log2 n = n log2 n. i=1

i=1

C-4.53) Hint Try to bound a significant number of the terms from below.

C-4.53) Solution For convenience assume that n is even. Then n

n

n

n

∑ log2 i ≥ ∑ log2 i ≥ ∑ log2 n/2 = ∑ (log2 n) − 1 = i=1

i=n/2

i=n/2

i=n/2

1 1 1 (n/2 + 1) log 2 n − n/2 = n log2 n + ( n log2 n + log2 n − n/2) ≥ n log n.

4 4 4 for n ≥ 4.

C-4.54) Hint Consider writing a pseudocode description of this algorithm and note its loop structure.

C-4.55) Hint Number each bottle and think about the binary expansion of each bottle’s number.

C-4.55) Solution Number each bottle from 1 to n. Select ⌈log n⌉ tasters and map each taster to a bit. On the first day of the month, a taster samples a wine if, in the binary representation of the wine’s number, his bit is 1.

For example, if taster A is assigned to the lowest order bit and there are 5 bottles, he will sample bottles 1, 3, and 5. If taster B is assigned to the highest order bit, he will sample bottles 4 and 5.

After the month is over, the number of the poisoned bottle can be determined. If a taster dies, then the bit they mapped to is a 1 in the poisoned bottle’s number. Otherwise, the bit is a 0.

C-4.56) Hint Use an auxiliary array that keeps counts for each value.

23 C-4.57) Hint You might wish to use an auxiliary array of size at most 4n.

C-4.57) Solution Use a boolean array of size at most 4n, where index i is true if and only if i is in the sequence. Initially, all cells are false, then process the sequence setting cell i to true for each integer i in A. At the end, scan the array for a false cell. The corresponding index is not in the list. Note that such a cell must exist, since there are at least 2n k-bit positive integers. It takes O(n) time to compute this value.

C-4.58) Hint Argue why you have to look at all the integers in A. C-4.58) Solution Any algorithm that misses even one integer in A and reports that some integer i is not in A is overlooking the possibility that the missed value in A is i.

C-4.59) Hint Start out by finding the integer in A with maximum absolute value.

C-4.59) Solution Find the integer in A with maximum absolute value.

Add one to twice the absolute value of this integer.

Projects P-4.60) Hint Choose representative values of the input size n, and run at least 5 tests for each size value n.

P-4.61) Hint Try to reuse your code as much as possible.

P-4.62) Hint You should try several runs over many different problem sizes.

P-4.63) Hint Do a type of “binary search” to determine the maximum effective value of n for each algorithm.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

5

Recursion

Hints and Solutions Reinforcement R-5.1) Hint Don’t forget about the space used by the method stack.

R-5.1) Solution If the array has 1 element, that is the maximum. Otherwise, consider the bigger of the first element or the maximum of the other n − 1 elements. The running time and space usages is O(n).

R-5.2) Hint When the algorithm finds a match, does it know where?

R-5.2) Solution public static int binarySearch(int[ ] data, int target, int low, int high) { if (low > high) // failed search return −1; else { int mid = (low + high) / 2; if (target == data[mid]) return mid; // index of found match else if (target < data[mid]) return binarySearch(data, target, low, mid − 1); else return binarySearch(data, target, mid + 1, high); } } R-5.3) Hint This is probably the first power algorithm you were taught.

R-5.3) Solution

25 return 2 ∗ 16 = 32 power(2, 5) return 2 ∗ 8 = 16 power(2, 4) return 2 ∗ 4 = 8 power(2, 3) return 2 ∗ 2 = 4 power(2, 2) return 2 ∗ 1 = 2 power(2, 1) return 1 power(2, 0)

R-5.4) Hint Be sure to get the integer division right.

R-5.4) Solution return 512 ∗ 512 = 262144 power(2, 18) return 16 ∗ 16 ∗ 2 = 512 power(2, 9) return 4 ∗ 4 = 16 power(2, 4) return 2 ∗ 2 = 4 power(2, 2) return 1 ∗ 1 ∗ 2 = 2 power(2, 1) return 1 power(2, 0)

R-5.5) Hint You can model your figure after Figure 5.11.

R-5.5) Solution 0

1

2

3

4

4

3

6

2

5

5

3

6

2

4

5

2

6

3

4

R-5.6) Hint You should draw small boxes or use a big paper, as there are a lot of recursive calls.

Chapter 5. Recursion

26

R-5.7) Hint Start with the last term.

R-5.7) Solution The general case is Hn = Hn−1 + n1 .

R-5.8) Hint Process the string from right to left.

R-5.8) Solution Use a single-digit as the base case. For a multiple-digit string, let s′ = sd for digit d. We have that value(s′ ) = d + 10 ∗ value(s).

R-5.9) Hint You can rely on bitwise operations to interpret n in binary.

R-5.9) Solution public static double power(double x, int n) { int k = 0; while ((1 << k) <= n) k++; double answer = 1; for (int j=k−1; j >= 0; j−−) { answer ∗= answer; if (((1 << j) & n) > 0) answer ∗= x; } return answer; } R-5.10) Hint You can use two recursive methods that look like BinarySum.

Creativity C-5.11) Hint The integer part of the base-two logarithm of n is the number of times you can divide by two before you get a number less than 2.

C-5.12) Hint Consider reducing the task of telling if the elements of an array are unique to the problem of determining if the last n − 1 elements are all unique and different than the first element.

C-5.13) Hint You need subtraction to count down from m or n and addition to do the arithmetic needed to get the right answer.

C-5.13) Solution The recursive algorithm, product(n, m), for computing product using only addition and subtraction, is as follows: If m = 1 return n. Otherwise, return n plus the result of a recursive call to the method product with parameters n and m − 1.

C-5.14) Hint Define a recurrence equation.

C-5.14) Solution let R(c) denote the number of dashes drawn by drawInterval(c).

We prove by induction that R(c) = 2c+1 − c − 2. As a base case, we note that drawInterval(0) does not produce any output, and that R(0) =

27 20+1 − 0 − 2 = 0. For c > 0, we note that drawInterval(c) invokes two recursive calls of drawInterval(c − 1), and a call to drawLine that produces c dashes. Therefore, R(c) = c + 2R(c − 1), and by the inductive hypothesis, R(c) = c + 2 2(c−1)+1 − (c − 1) − 2 = c + 2 (2c − c − 1) = c + 2c+1 − 2c − 2 = 2c+1 − c − 2.

C-5.15) Hint Start by removing the first element x and computing all the subsets that don’t contain x.

C-5.16) Hint Consider first the subproblem of moving all but the n th disk from peg a to another peg using the third as “temporary storage.”

C-5.17) Hint Output to System.out one character at a time.

C-5.17) Solution void printReverse(String s, int n) { if (n >= 0) { System.out.print(s.charAt(n)) printReverse(s, n−1); } } void printReverse(String s) { printReverse(s, s.length( ) − 1); }

C-5.18) Hint Check the equality of the first and last characters and recur (but be careful to return the correct value for both odd- and even-length strings).

C-5.19) Hint Write your recursive method to first count vowels and consonants.

C-5.20) Hint Consider whether the last element is odd or even and then put it at the appropriate location based on this and recur.

C-5.20) Solution

Chapter 5. Recursion

28

void organize(int[ ] data, int low, int high) { if (low < high) { if (data[high] & 1 == 0) { // even int temp = data[high]; data[high] = data[low]; data[low] = temp; organize(data, low+1, high); // data[low] is known to be even } else { organize(data, low, high−1); // data[high] is known to be odd } } } void organize(int[ ] data) { organize(data, 0, data.length − 1); } C-5.21) Hint Begin by comparing the first and last elements in a range of indices in A. C-5.21) Solution This problem can effectively be solved using the same technique as Exercise C-5.20.

C-5.22) Hint The beginning and the end of a range of indices in A can be used as arguments to your recursive method.

C-5.22) Solution The solution makes use of the method FindPair(A, i, j, k) below, which given the sorted subarray A[i.. j] determines whether there is any pair of elements that sums to k. First it tests whether A[i] + A[ j] < k.

Because A is sorted, for any j′ ≤ j, we have A[i] + A[ j′ ] < k. Thus, there is no pair involving A[i] that sums to k, and we can eliminate A[i] and recursively check the remaining subarray A[i + 1.. j]. Similarly, if A[i] + A[ j] > k, we can eliminate A[ j] and recursively check the subarray A[i.. j − 1]. Otherwise, A[i] + A[ j] = k and we return true. If no such pair is ever found, eventually all but one element is eliminated (i = j), and we return false.

Algorithm FindPair(A, i, j, k): Input: An integer subarray A[i.. j] and integer k Output: Returns true if there are two elements of A[i.. j] that sum to k if i == j then return false else if A[i] + A[ j] < k then return FindPair(A, i + 1, j, k)

29 else if A[i] + A[ j] > k then return FindPair(A, i, j − 1, k) else return true C-5.23) Hint Check the last element and then recur on the rest of A. C-5.24) Hint Look for a geometric series.

C-5.24) Solution The running time is O(n), as it is O(n + n/2 + n/4 + n/8 + · · · ).

C-5.25) Hint Recur on the first n − 1 positions.

C-5.25) Solution Let us define a method reverse(L, n), which reverses the first n ≤ L.size() nodes in L, and returns a pointer end to the node just after the nth node in L (end = null if n = L.size()). If L.size() ≤ 1, we are done, so let us assume L has at least 2 nodes. If n = 1, then we return L.first().next(). Otherwise, we recursively call reverse(L, n − 1), and let end denote the returned pointer to the nth node in L. We then set ret to end.next() if n < L.size(), and to null otherwise. We then insert the node pointed to by end at the front of L and we return ret. The total running time is O(n).

C-5.26) Hint View the chain of nodes following the head node as forming themselves another list.

Projects P-5.27) Hint Review use of the java.io.File class.

P-5.28) Hint Use recursion in your main solution engine.

P-5.29) Hint Consider a small example to see why the binary representation of the counter is relevant.

P-5.30) Hint Note the recursive nature of the problem.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

6

Stacks, Queues, and Deques

Hints and Solutions Reinforcement R-6.1) Hint If a stack is empty when pop is called, its size does not change.

R-6.1) Solution The size of the stack is 25 − 10 + 3 = 18.

R-6.2) Hint It is one less than the size of S. R-6.2) Solution 17.

R-6.3) Hint Use a paper and pencil with eraser to simulate the stack.

R-6.3) Solution 3, 8, 2, 1, 6, 7, 4, 9 R-6.4) Hint Transfer items one at a time.

R-6.4) Solution static <E> void transfer(Stack<E> S, Stack<E> T) { while (!S.isEmpty( )) { T.push(S.pop( )); } } R-6.5) Hint First check if the stack is already empty.

R-6.5) Solution If the stack is empty, then return (the stack is empty).

Otherwise, pop the top element from the stack and recur.

R-6.6) Hint Give a recursive definition.

R-6.6) Solution An arithmetic expression has matching grouping symbols if it has one of the following structures, where S denotes an arithmetic expression without grouping symbols, and E, E ′ , and E ′′ recursively denote an arithmetic expression with matching grouping symbols: • S • E ′ (E)E ′′ • E ′ [E]E ′′ • E ′ {E}E ′′

31 R-6.7) Hint If a queue is empty when dequeue is called, its size does not change.

R-6.7) Solution The size of the queue is 32 − 15 + 5 = 22.

R-6.8) Hint Each successful dequeue operation causes that index to shift circularly to the right.

R-6.8) Solution f=10.

R-6.9) Hint Use a paper and pencil with eraser to simulate the queue.

R-6.9) Solution 5, 3, 2, 8, 9, 1, 7, 6 R-6.10) Hint Use operations at the appropriate ends of the deque.

R-6.11) Hint Use operations at the appropriate ends of the deque.

R-6.12) Hint Use a paper and pencil to simulate the deque.

R-6.12) Solution 9, false, 9, 2, 7, 6, 2, 1 R-6.13) Hint Use the results of removal methods as arguments to insertion methods.

R-6.13) Solution D.addLast(D.removeFirst()) D.addLast(D.removeFirst()) D.addLast(D.removeFirst()) Q.enqueue(D.removeFirst()) Q.enqueue(D.removeFirst()) D.addFirst(Q.dequeue()) D.addFirst(Q.dequeue()) D.addFirst(D.removeLast()) D.addFirst(D.removeLast()) D.addFirst(D.removeLast()) R-6.14) Hint Use the results of removal methods as arguments to insertion methods. In addition, you will need to use more of the stack for temporary storage.

R-6.14) Solution D.addLast(D.removeFirst()) D.addLast(D.removeFirst()) D.addLast(D.removeFirst()) S.push(D.removeFirst()) D.addLast(D.removeFirst()) D.addFirst(Spop()) D.addFirst(D.removeLast()) D.addFirst(D.removeLast()) D.addFirst(D.removeLast()) D.addFirst(D.removeLast())

Chapter 6. Stacks, Queues, and Deques

32

R-6.15) Hint You might start by concatenating the bodies of the dequeue and enqueue methods and then look to avoid redundancy.

R-6.15) Solution public void rotate( ) { if (sz < data.length) { // object must move within the array int avail = (f + sz) % data.length; data[avail] = data[f]; data[f] = null; } f = (f + 1) % data.length; }

Creativity C-6.16) Hint Pop the top integer, but remember it.

C-6.16) Solution x = S.pop( ); if (x < S.top( )) x = S.pop( ); Note that if the largest integer is the first or second element of S, then x will store it. Thus, x stores the largest element with probability 2/3.

C-6.17) Hint You will need to do three transfers.

C-6.17) Solution transfer(S, A); transfer(A, B); transfer(B, S);

// contents in A are in reverse order as original // contents in B are in same order as original // contents in S are in reverse order as original

C-6.18) Hint After finding what’s between the < and > characters, the tag is only the part before the first space (if any).

C-6.19) Hint Use a stack.

C-6.20) Hint You can still use R as temporary storage, as long as you never pop its original contents.

C-6.20) Solution Let r, s and t denote the original sizes of the stacks.

Make s calls to R.push(S.pop( )) Make t calls to R.push(T.pop( )) Make s + t calls to S.push(R.pop( )) C-6.21) Hint Use a stack to reduce the problem to that of enumerating all permutations of the numbers {1, 2, . . . , n − 1}.

33 C-6.22) Hint Think of the stacks like jugs and the dump operations like water being poured between two jugs.

C-6.22) Solution dump(A,B) // A=95, B=5, C=0 dump(B,C) // A=95, B=2, C=3 dump(C,A) // A=98, B=2, C=0 dump(B,C) // A=98, B=0, C=2 dump(A,B) // A=93, B=5, C=2 dump(B,C) // A=93, B=4, C=3 C-6.23) Hint Use the stack to store the elements yet to be used to generate subsets and use the queue to store the subsets generated so far.

C-6.24) Hint Think of how you might use Q to process the elements of S twice.

C-6.24) Solution The solution is to actually use the queue Q to process the elements in two phases. In the first phase, we iteratively pop each the element from S and enqueue it in Q, and then we iteratively dequeue each element from Q and push it into S. This reverses the elements in S. Then we repeat this same process, but this time we also look for the element x. By passing the elements through Q and back to S a second time, we reverse the reversal, thereby putting the elements back into S in their original order.

C-6.25) Hint Rotate elements within the queue.

C-6.25) Solution One approach to implement the stack ADT using a queue Q, simply enqueues elements into Q whenever a push call is made.

This takes O(1) time to complete. For pop calls, we make n − 1 calls to Q.enqueue(Q.dequeue( )), where n is the current size, and then return Q.dequeue( ), as that is the most recently inserted element. This requires O(n) time. We can use a similar approach for top, but rotating the answer back to the end of the queue.

A better approach is to align the elements of the queue so that the “top” is aligned with the front of the queue. To push an element, we enqueue it and then immediately make n − 1 calls to Q.enqueue(Q.dequeue( )).

This requires O(n) time, but with that orientation, both pop and top can be implemented in O(1) time by a respective call to dequeue or front.

C-6.26) Hint You can try it out C-6.26) Solution The variable f could have been initialized to any valid index from 0 to capacity − 1, since the front of the queue need not be initially aligned with the front of the array. Of course, since different queues will have different capacities, 0 is a convenient choice for all.

C-6.27) Hint See Section 3.6 for a discussion of cloning data structures.

C-6.27) Solution

34

Chapter 6. Stacks, Queues, and Deques public ArrayStack<E> clone( ) throws CloneNotSupportedException { ArrayStack<E> other = (ArrayStack<E>) super.clone( ); other.data = data.clone( ); return other; } C-6.28) Hint See Section 3.6 for a discussion of cloning data structures.

C-6.28) Solution Similarly to previous solution for ArrayStack.

C-6.29) Hint You are welcome to modify the SinglyLinkedList class to add necessary support C-6.29) Solution Such a method could be implemented by calling list.concatenate(Q2.list) if we add the following method to the SinglyLinkedList class: /∗∗ ∗ Append all elements of other to the end of this list. ∗ The other list will become empty as a result. ∗/ public void concatenate(SinglyLinkedList<E> other) { if (head == null) { head = other.head; } else { tail.setNext(other.head); } tail = other.tail; size += other.size; // clear other list other.head = other.tail = null; other.size = 0; } C-6.30) Hint Use separate indices for the two ends.

C-6.31) Hint Think of using one stack for each end of the deque.

C-6.32) Hint Use the deque like a stack.

C-6.33) Hint Think of the queues like boxes and the integers like red and blue marbles.

C-6.33) Solution Alice should put on even integer in C and all the other 99 integers in D. This gives her a 74/99 (roughly 74.7%) chance of winning.

C-6.34) Hint Lazy and Crazy should only go across once.

C-6.34) Solution Mazie and Daisy go across (4 min.), Daisy comes back (4 min.), Crazy and Lazy go across (20 min.), Mazie comes back (2 min.), and then Mazie and Daisy go across (4 min.).

35

Projects P-6.35) Hint You will need to use a stack.

P-6.36) Hint Define two stacks that are used match sell orders with buy orders.

P-6.37) Hint Start one stack at each end of the array, growing toward the center.

P-6.38) Hint How does this functionality compare to a deque?

P-6.39) Hint Think carefully about the orientation of the linked list.

P-6.40) Hint The section on the Deque ADT gives advice on using a circular array implementation.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

7

List and Iterator ADTs

Hints and Solutions Reinforcement R-7.1) Hint Draw the state of the array after each operation using a pencil with a good eraser.

R-7.2) Hint Use the size method to help keep track of the top of stack.

R-7.3) Hint Use the obvious correspondance.

R-7.3) Solution Deque Method size() isEmpty() first() last() addFirst(e) addLast(e) removeFirst() removeLast()

Realization with Array List Methods size() isEmpty() get(0) get(size() − 1) add(0, e) add(size(), e) remove(0) remove(size() − 1)

R-7.4) Hint Explain, in particular, why add and remove both run in linear time.

R-7.4) Solution The methods size() and isEmpty() run in constant time because of the instance variable n. This variable can easily be returned or compared to give the results for these two methods. The method elemAtRank(i) is also constant because of the underlying array implementation of the array list. Since we are using an array, an access at a particular index is done with a simple A[i] reference. The replace(i, e) method can also be done with a quick access to an index and a change of element, thus, it is also constant. However, the methods add and remove take linear time due to the nature of an array. When inserting at certain index, we must first move

Chapter 7. List and Iterator ADTs

32

over (increase the index of) every element that will follow (has a higher index than) this element. This can take up to n moves for an array of size n. Likewise, for a removal, all of the elements that followed the removed element in the array list previous to the removal now need to be shifted down (lowered in index). Again, this can take up to n moves.

R-7.5) Hint Notice that the existing resize method can be used to shrink the array.

R-7.5) Solution public void trimToSize( ) { if (data.length != size) resize(size); } R-7.6) Hint Now we are charging more for the growing, so we need to store more cyber-dollars with each element. Calculate the number needed for growing and this will help you determine the number you need to save, which in turn tells you one less than you need to charge each push.

R-7.6) Solution Let us assume that one cyber-dollar is enough to pay for the execution of each push operation in S, excluding the time spent for growing the array. Now, however, growing the array from size k to size 2k requires 3k cyber-dollars. Once again, we will need to account for this cost with our “bank account” in the elements of the last half of the array list. To grow from 2i to 2i+1 , we need 3 ∗ 2i cyber dollars. Thus, from the second half of the array list—the last 2i−1 elements we need to have 6 cyber-dollars apiece stored away. So, overall, we need to charge 7 cyberdollars for each push operation: 6 for future growth and 1 for insertion.

R-7.7) Hint Consider how much cyber “money” is saved up from one expansion to the next.

R-7.8) Hint Consider the running time for adding the ith element, and characterize the total running time using a summation.

R-7.8) Solution The total running time for adding n elements in this way is O(n2 ).

R-7.9) Hint You cannot use the existing resize method, as written.

R-7.9) Solution

33 public void add(int i, E e) { checkIndex(i, size + 1); if (size == data.length) { E[ ] temp = (E[ ]) new Object[2∗data.length]; for (int k=0; k < i; k++) temp[k] = data[k]; temp[i] = e; for (int k=i+1; k < size+1; k++) temp[k] = data[k1]; data=temp; } else { for (int k=size−1; k >= i; k==) data[k+1] = data[k]; data[i] = i; } size++; } R-7.10) Hint Change the push method so that it resizes the array when needed.

R-7.11) Hint Exploit the ability of going before or after positions you have access to through the positional methods, but be sure to check for the empty-list case.

R-7.11) Solution public Position<E> addLast(E e) { if (isEmpty( )) return addFirst(e); else return addAfter(last( ), e); } public Position<E> addBefore(Position<E> p, E e) { if (p == first( )) return addFirst(e); else return addAfter(before(p), e); } (We don’t actually need to use the after(p) method.)

R-7.12) Hint Count the steps while traversing the list until encountering position p.

R-7.12) Solution

34

Chapter 7. List and Iterator ADTs public int indexOf(Position<E> p) { int count; Position<E> walk = first( ); while (walk != p) { count++; walk = after(walk); } return count; }

// assuming p is valid

R-7.13) Hint Remember to use the equals method to test equality.

R-7.13) Solution public Position<E> findPosition(E e) { Position<E> walk = first( ); while (walk != null && !e.equals(walk.getElement( ))) walk = after(walk); return walk; } R-7.14) Hint Try executing such a command.

R-7.14) Solution This causes an internal inconsistency for both the list upon which it is invoked and the list to which p belongs. A node containing the new element will be linked into the list to which p belongs, but the size variable will be updated for the list upon which the method is invoked.

R-7.15) Hint Carefully map the public methods of the queue interface to the concrete behaviors of the LinkedPositionalList class.

R-7.16) Hint You may do this as a snapshot or as a cursor in the current list. In either case, describe the pointer hops needed to implement the hasNext and next methods.

R-7.17) Hint For an infinite progression, you may have hasNext( ) return true.

R-7.18) Hint Remember to use the equals method to test equality.

R-7.18) Solution public boolean contains(Object o) { for (int k=0; k < size; k++) if (data[k].equals(o)) return true; return false; }

35 R-7.19) Hint For good measure, set all references to null.

R-7.19) Solution public void clear( ) { for (int k=0; k < size; k++) data[k] = null; size = 0; } R-7.20) Hint Model your solution off the book’s example of shuffling an array.

R-7.21) Hint Implement the move-to-front using a pencil and eraser.

R-7.21) Solution {e, d, b, f , c, a} R-7.22) Hint Consider the two extreme cases of how we could distribute m accesses across n elements.

R-7.22) Solution The minimum is 0, since we could have accessed each element exactly k times. the maximum is n − 1, since we could have accessed just one element kn times.

R-7.23) Hint The first should be last, both physically and in terms of how long ago it has been accessed.

R-7.24) Hint You might wish to add functionality to the nested Item class.

R-7.24) Solution If we do not provide a setCount method for the Item class, an alternate approach is to create new Item instances for the reset. public void resetCounts( ) { Position<Item<E>> walk = list.first( ); while (walk != null) { list.set(walk, new Item<E>(walk.getElement( ).getValue( ))); walk = list.after(walk); } }

Creativity C-7.25) Hint Think about how to extend the circular array implementation of the queue ADT given in the previous chapter.

C-7.25) Solution As we did with the ArrayQueue class, we recommend maintaining index f to the front of the list and size, which is the current number of elements. The element at index k in the list will be found at index (f+k) % data.length in the underlying data array. Insertions and removals can be processed at either end in constant time.

Chapter 7. List and Iterator ADTs

36

C-7.26) Hint We suggest realigning the front of the list with index 0 during a resize operation.

C-7.27) Hint Make sure that the clone has its own array.

C-7.27) Solution public ArrayList<E> clone( ) throws CloneNotSupportedException { ArrayList<E> other = (ArrayList<E>) super.clone( ); other.data = data.clone( ); return other; } C-7.28) Hint Consider randomly shuffling the deck one card at a time.

C-7.28) Solution For each i from 0 to n − 1, swap the element at index i with a randomly chosen element from the array list.

C-7.29) Hint The existing resize method can be used to shrink the array.

C-7.30) Hint You can predict precisely when a resize occurs during this process, and take the sum of those costs.

C-7.31) Hint Apply the amortized analysis accounting technique using a monetary accounting scheme with extra funds for both insertions and removals.

C-7.32) Hint Consider, after any resize takes place, how many subsequent operations are needed to force another resize.

C-7.33) Hint Try to oscillate between growing and shrinking.

C-7.33) Solution This problem is different from the previous, because the threshold of N/2 is unfortunately aligned with the doubling rule used for an increase. Assume that an underlying array has capacity k for large k.

When we push a (k + 1)st element, the array will be doubled to capacity 2k, at a cost of Ω(k). If we then pop two elements, the k − 1 remaining elements is less than half of the array’s capacity, so a resize to shrink the array will be performed with cost of Ω(k). By repeatedly pushing two elements and popping two elements, there will be a linear amount of work for every two operations.

C-7.34) Hint Consider using one stack to collect incoming elements, and another as a buffer for elements to be delivered.

C-7.34) Solution Consider the following implementation.

37 public <E> class SolnQueue { private Stack<E> incoming = new Stack<>( ); private Stack<E> outgoing = new Stack<>( ); private void transfer( ) { while (!incoming.isEmpty( )) outgoing.push(incoming.pop( )); } public int size( ) { return incoming.size( ) + outgoing.size( ); } public boolean isEmpty( ) { return (incoming.isEmpty( ) && outgoing.isEmpty( )); } public void enqueue(E e) { incoming.push(e); } public E front( ) { if (isEmpty( )) return null if (outgoing.isEmpty( )) transfer( ); return outgoing.top( ); } public E dequeue( ) { if (isEmpty( )) return null if (outgoing.isEmpty( )) transfer( ); return outgoing.pop( ); } } The correctness can be proven by arguing that elements in the outgoing stack are ordered with the older elements toward the top, and that all elements in the outgoing stack are older than any elements in the incoming stack.

Although the worst-case running time for front and dequeue are O(n) due to a transfer, the O(1) amortized bound can be seen from the fact that

Chapter 7. List and Iterator ADTs

38

any given element participates in at most one transfer in its lifetime, and thus the total time spent in the transfer loop during a sequence of k queue operations is k.

C-7.35) Hint We suggest realigning the front of the queue with index 0 during a resize operation.

C-7.36) Hint Code Fragment 7.6 demonstrates a traversal of a positional list.

C-7.36) Solution public Position<E> positionAtIndex(index i) { if (i < 0 | | i >= size( )) throw new IndexOutOfBoundsExcpetion("Invalid index"); Position<E> walk = first( ); for (int k=0; k < i; k++) walk = after(walk); return walk; } C-7.37) Hint Compare to size( )/2.

C-7.38) Hint Be careful of boundary conditions.

C-7.39) Hint Find the syntax to remove and reinsert the element.

C-7.40) Hint Draw pictures of the linked list operations needed to move p to the front.

C-7.40) Solution public void moveToFront(Position<E> p) { Node<E> node = validate(p); if (node != header.getNext( )) { // remove node from its current location node.getPrev( ).setNext(node.getNext( )); node.getNext( ).setPrev(node.getPrev( )); // insert node at front of list (just after header) node.setPrev(header); node.setNext(header.getNext( )); header.getNext( ).setPrev(node); header.setNext(node); } } C-7.41) Hint Compare to the clone method provided for the SinglyLinkedList in Section 3.6.2.

C-7.42) Hint You obviously need to switch next and prev pointers, but make sure you do it in the right order.

39 C-7.43) Hint It is okay to be inefficient in this case.

C-7.43) Solution Algorithm addBefore(p, e): Let i be the index associated with position p for j from size-1 down to i do Move the entry at index j to index j + 1 Update that position to note its new index j + 1 Create a new entry for element e and insert at index i C-7.44) Hint Convert the two parts to two separate lists as sublists.

C-7.45) Hint Have each position keep track of what list it is in.

C-7.45) Solution Since we would not want to walk an entire list to verify that a position belongs to it, a better approach, if such robustness is desired, is to add a new field to each node which is a reference to the list to which it belongs. That can be initialized when a node is added to the list, and should be set back to null when a node is removed from the list (to denote it as deprecated).

C-7.46) Hint Watch out for the special case when p and q are neighbors.

C-7.47) Hint There is a trade-off between insertion and searching depending on whether the entries in L are sorted.

C-7.48) Hint You should replace the first() and last() methods with a method abstracting the cursor.

C-7.49) Hint Reread Section 7.5.1 carefully.

C-7.50) Hint Have each iterator keep an instance variable that can be compared with a similar variable for the underlying list to determine if the list has changed since the iterator was created.

C-7.50) Solution Each list can maintain an integer value that is incremented each time a method is called that modifies the state of the list in a way that should cause iterators to fail. Each iterator should keep a variable which equals that value the list had when the iterator was created. Then, whenever the iterator is used in an operation, if the current value stored by the list is not the same as that stored by the iterator, the iterator should fail.

C-7.51) Hint Avoid index-based operations.

C-7.52) Hint You can either use index-based methods or positional ones, but the index-based ones would be more intuitive.

C-7.53) Hint Think about maintaining the sequence of the last n accesses in addition to the list L itself.

C-7.53) Solution We will maintain a global count of the number of accesses in the sequence, and then with each element in the list, we will

Chapter 7. List and Iterator ADTs

40

keep track of the time stamp for its most recent access. After each operation is performed, we examine the last item in the list and if its most recent access is no longer within the most recent n operations, that element is deleted. (Note that only one element can be purged after a single operation, as it can be the only one who’s most recent access was precisely n + 1 operations ago.)

C-7.54) Hint For this lower bound, assume that when an element is accessed we search for it by traversing the list starting at the front.

C-7.54) Solution For this lower bound, we assume that when an element is accessed, we must search for it by traversing the list starting at the front.

We consider n elements, and access them each once in the order 1, 2, . . . n, and then access them each again in the original order, repeating n such phases of access. Other than when each element is originally inserted, each of the remaining accesses is to the element at the end of the list, and thus we have n(n − 1) accesses which take n steps, thus Ω(n3 ) time overall.

C-7.55) Hint Be sure to handle the case where every pair (x, y) in A and every pair (y, z) in B have the same y value.

C-7.56) Hint You should be able to achieve O(n) time.

C-7.57) Hint You may wish to consider the coverage of insertion-sort on an array from an earlier chapter.

Projects P-7.58) Hint Get coding!

P-7.59) Hint Review Exercise C-7.45 and its hint.

P-7.60) Hint Keep all cards in a single list, and four positions to demark the beginning of the respective suits.

P-7.61) Hint Use a position instance variable to keep track of the cursor location.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

8

Trees

Hints and Solutions Reinforcement R-8.1) Hint Be sure not to get confused between depth (which is for a single node) and height (which is for the entire tree).

R-8.2) Hint Recall that the worst-case running time for the depth method is O(n).

R-8.3) Hint Use the definitions of height and depth, and note that the height of the tree has to be realized by some path from the root to an external node. In addition, using induction is the easiest justification technique to use with this proposition.

R-8.4) Hint Use a new parameter, n p , which refers to the number of positions in the subtree rooted at p.

R-8.4) Solution The running time is O(n p ), where n p is the number of positions in the subtree rooted at position p.

R-8.5) Hint Review the binary tree ADT. R-8.6) Hint Consider using dummy nodes.

R-8.7) Hint You need to give four values—the minimum and maximum number of internal nodes and the same for external nodes. In addition, one of these four values is 1.

R-8.7) Solution A tree that is one long path would have n − 1 internal nodes and 1 external node. A tree that is proper (and thus odd n) would n+1 have n−1 2 internal nodes and 2 external nodes.

R-8.8) Hint Use the formulas presented in the book that relate external nodes, internal nodes, and height.

R-8.9) Hint Consider how any proper binary tree with n nodes can be related to a proper binary tree with n − 2 nodes.

R-8.10) Hint Each subtree is rooted at a node of the tree; give the value associated with each such node.

Chapter 8. Trees

42

R-8.11) Hint This one is a real puzzler, and it doesn’t even use the operators + and ∗.

R-8.11) Solution The tree expresses the formula (6/(1 − (5/7))).

R-8.12) Hint Review how arithmetic expressions can be represented with binary trees.

R-8.13) Hint Assume that the container of children is implemented as a positional list.

R-8.13) Solution The size and isEmpty methods run in O(1) assuming we maintain a top-level count of the number of nodes in the tree. The methods root, parent, isRoot, isInternal, isExternalare also constant since we need only to check local fields of the node or the tree’s root to determine these.

The numChildren method is constant-time, because it is simply the size method of the secondary container of children. Reporting children(p) requires O(c p + 1) time because it requires iterating through the entire collection of children (even if the container were empty). The analysis of depth and height were given in Section 8.1.3.

R-8.14) Hint Think about a tree that is really a path.

R-8.15) Hint Recall the definition of the level numbering and use this definition when passing information from a node to its children.

R-8.16) Hint All of these methods can be easily performed using formulas involving level numbers.

R-8.17) Hint Use a substitution of g(p) = f (p) + 1.

R-8.18) Hint Draw the tree on a separate sheet of paper and then mark nodes as they are visited, writing down the output produced for each visit.

R-8.19) Hint Draw the tree on a separate sheet of paper and then mark nodes as they are visited, writing down the output produced for each visit.

R-8.19) Solution 3 1 + 3 x 9 5 - 2 + - 3 7 4 - x 6 + R-8.20) Hint Draw a tree with one node, one with two nodes, and then one with three nodes.

R-8.20) Solution It is not possible for the postorder and preorder traversal of a tree with more than one node to visit the nodes in the same order. A preorder traversal will always visit the root node first, while a postorder traversal node will always visit an external node first.

It is possible for a preorder and a postorder traversal to visit the nodes in the reverse order. Consider the case of a tree with only two nodes.

R-8.21) Hint Draw a tree with one node and then one with three nodes (and note it is impossible to draw a proper binary tree with exactly two nodes).

43 R-8.21) Solution It is not possible for the post- and preorder traversals to visit the nodes of a proper binary tree in the same order for the same reason in the previous question.

It is not possible for the post- and preorder traversals to visit the nodes of a proper binary tree in the reverse order. Let a be the root of a proper binary tree and let T1 and T2 be the left and right subtrees. A postorder traversal would visit the postorder traversal of T1 , the postorder traversal of T2 and then node a while the preorder traversal would visit node a, the preorder traversal of T1 and then the preorder traversal of T2 . Clearly the postorder and preorder traversals cannot be the reverse of each other since in both cases, all the nodes of T1 are visited before all the nodes of T2 .

R-8.22) Hint Draw the tree starting with the beginning and end characters of the two character strings.

R-8.22) Solution The tree is drawn below. ✗✔ E .

✑ ✖✕ ◗ ✑ ◗ ✑ ◗ ✑ ◗ ✑ ◗ ✑ ◗ ✗✔ ✗✔

X

✖✕ ◗ ✑✑ ◗◗✗✔ ✗✔ ✑

A

✖✕ ✁ ❆ ✁ ❆ ✗✔ ✗✔

M

N

✖✕

U

✖✕

F

✖✕ ✖✕

R-8.23) Hint We already got you started. . .

R-8.23) Solution {1} {2, 3, 4} {3, 4, 5, 6} {4, 5, 6, 7, 8, 9, 10} and so on.

R-8.24) Hint Draw the tree again and use a pencil and paper to mark how the recursive calls move around the tree.

R-8.25) Hint The trick is to keep track of how much of the current line you have already used up and whether the next piece of output will exceed the 80 character limit.

R-8.26) Hint Argue that this method basically performs the same computations as a familiar tree traversal method.

Chapter 8. Trees

44

R-8.26) Solution The running is O(n) since parenthesize is just a preorder traversal with output.

Creativity C-8.27) Hint Define the method recursively.

C-8.28) Hint Modify an algorithm for computing the depth of each position so that it computes path lengths at the same time.

C-8.29) Hint Use the fact that we can build T from a single root tree via a series of pairs of insertLeft and insertRight operations.

C-8.30) Hint The minimum value will occur when T has one external node.

C-8.31) Hint Consider how you could possibly combine a tree with maximum depth with a tree with minimum depth.

C-8.31) Solution Let T1 be a tree of n/2 nodes in a single path from the root to a single external node v. And let T2 be a tree of n/2 nodes having ⌊n/2⌋ + 1 external nodes. Now, create T by attaching T2 to T1 at v.

C-8.32) Hint First show that there is a node with three external node children, and then consider what changes when the children of that node are all removed.

C-8.32) Solution We will show this using induction. For nI = 0, then nE = 2nI + 1 = 1. This is obviously true. For nI = 1, then nE = 2nI + 1 = 2 + 1 = 3. Again, this is obviously true from our problem definition.

Now let us assume that the nE equation holds true for k′ < k, i.e., for any nI = k′ < k, nE = 2nI + 1.

Now consider nI = k. Then, nE = 2(k − 1) + 1 + (3 − 1). That is, the number of external nodes is equal to the number of external nodes for a tree with k − 1 internal nodes plus 3 (we added an internal node which must have 3 children) minus 1 (in creating the new internal node, we made an external node into an internal node). Thus, nE = 2k − 2 + 3 = 2k + 1.

This is what we needed to show.

C-8.33) Hint Use the definition to derive a recursive algorithm.

C-8.34) Hint Explore the different ways you might attach external nodes at the bottom level of a tree.

C-8.35) Hint Explore with pen and paper.

C-8.35) Solution There are 5 such trees.

C-8.36) Hint Can you tell how many elements are removed?

C-8.36) Solution Based on our current representation, this would require O(n p ) time where n p is the number of nodes in the subtree rooted at position p.

45 C-8.37) Hint There are many special cases to consider when p and q neighbor each other.

C-8.38) Hint Try to avoid conditionals when possible.

C-8.39) Hint Recursion can be very helpful.

C-8.40) Hint Build the new tree in preorder fashion.

C-8.41) Hint You may use the technique from either of the previous two problems.

C-8.42) Hint Use a tree traversal.

C-8.42) Solution We can accomplish the task of printing the element stored at p along with the height of the subtree rooted at p by using a postorder traversal. During this traversal, we will find the height of each subtree. The height for a subtree at p will be 0 if p is a leaf and otherwise one more than the height of the max child. We can print out the element at p and its computed height during the postorder visit.

C-8.43) Hint Derive a formula that relates the depth of a position p to the depths of positions adjacent to p.

C-8.43) Solution This can be done using a preorder traversal. When doing a “visit” in the traversal, simply store the depth of the position’s parent incremented by 1. Now, every node will contain its depth.

C-8.44) Hint Try to compute node heights and balance factors at the same time.

C-8.44) Solution One way to do this is the following: for external nodes, set height and balance to be zero. Then, do the following for the post-visit method: Algorithm post-visit(): if v.isInternal(v) then if v.le f tchild.height > v.rightchild.height then v.height = v.le f tchild.height + 1; else v.height = v.rightchild.height + 1; v.balance = abs(v.rightchild.height − v.le f tchild.height); print v.balance C-8.45) Hint Think about what could be the worst-case number of nodes that would have to be traversed to answer each of these queries.

C-8.45) Solution The algorithms are as follows: Algorithm preorderNext(Node v): if v.isInternal() then return v’s left child else

Chapter 8. Trees

46 Node p = parent of v if v is left child of p then return right child of p else while v is not left child of p do v=p p = p.parent return right child of p Algorithm inorderNext(Node v): if v.isInternal() then Node p = left child of v while p has left child do p = left child of p return p else Node p = parent of v if v is left child of p then return p else while v is not left child of p do v=p p = p.parent return p Algorithm postorderNext(Node v): if v.isInternal() then p = parent of v if v is right child of p then return p else v = right child of p while v is not external do v = left child of v return v else p = parent of v if v is left child of p then return right child of p else return p

The worst-case running times for these algorithms are all O(h) where h is

47 the height of the tree T .

C-8.46) Hint Use a stack.

C-8.46) Solution Algorithm inorder(Tree T ): Stack S ← new Stack() Node v ← T .root() push v while S is not empty do while v is internal do v ← v.le f t push v while S is not empty do pop v visit v if v is internal then v ← v.right push v while v is internal do v ← v.le f t push v C-8.47) Hint The algorithm from Exercise C-8.45 will be useful.

C-8.48) Hint The algorithm from Exercise C-8.45 will be useful.

C-8.49) Hint The algorithm from Exercise C-8.45 will be useful.

C-8.50) Hint Use induction to show that no crossing edges are produced.

C-8.51) Hint Use induction to show that no crossing edges are produced.

C-8.52) Hint The answer to the first part of (c) is ”yes”.

C-8.52) Solution a) yes b) no c) yes, postorder.

C-8.53) Hint The y coordinates can be the same as in the binary tree case.

The trick, then, is to find a good substitute for the inorder number used in the binary tree drawing algorithm.

C-8.54) Hint First derive a formula for post(p) − pre(p).

C-8.54) Solution post(p) = desc(p) − 1 − depth(p) + pre(p). To prove this, consider the difference, post(p) − pre(p). This difference is equal to all the positions counted by postorder but not preorder (the strict descendants of p, whose number is desc(p) − 1) minus all the positions counted by preorder but not postorder (the ancestors of p, whose number is depth(p)).

Chapter 8. Trees

48

C-8.55) Hint It helps to know the relative depths of p and q.

C-8.55) Solution The algorithm is given below.

Algorithm LCA(Node v, Node w): int vd pth = v.depth int wd pth = w.depth while vd pth > wd pth do v = v.parent while wd pth > vd pth do w = w.parent while v 6= w do v = v.parent w = w.parent return v C-8.56) Hint Consider what numbers f (p) + 1, f (q) + 1, and f (a) + 1 look like in binary.

C-8.57) Hint Be careful—the path establishing the diameter might not include the root of the tree.

C-8.58) Hint Consider a recursive algorithm.

C-8.58) Solution The algorithm is given below.

Algorithm indentedParentheticRepresentation(Tree T , Position v, int indent): print out indent number of tabs if T.isExternal(v) then print v.element().toString() else indent+ = 1 print v.element().toString() + “(” Enumeration children of v = T.children(v) while children of v.hasMoreElements() do Position w = (Position) children of v.nextElement() indentedParentheticRepresentation(T, w, indent) indent− = 1 print out indent number of tabs C-8.59) Hint First convert the infix expression into its equivalent binary tree representation.

C-8.60) Hint Consider a recursive algorithm.

Projects P-8.61) Hint What are natural update methods for this representation?

49 P-8.62) Hint Use a Java list for the children.

P-8.63) Hint Review the definition of this representation to get the details right.

P-8.64) Hint You can use an ArrayList of positions to represent the tree path.

P-8.65) Hint Consider building the expression tree using a recursive algorithm, as described in the book.

P-8.66) Hint The essential part of this structure is just a binary tree, so take each part one step at a time.

P-8.67) Hint This is a huge project, so plan accordingly.

P-8.68) Hint Use recursion where appropriate.

P-8.69) Hint You don’t have to use the drawing algorithm presented in the book.

P-8.70) Hint You can use a generalization of the binary-tree drawing algorithm presented in the book.

P-8.71) Hint We are considering the tree of all descendants here.

P-8.72) Hint Use the drawing style presented in the book.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

9

Priority Queues

Hints and Solutions Reinforcement R-9.1) Hint Each removeMin operation takes O(log n) time.

R-9.2) Hint Observe that the keys are guaranteed to satisfy the heap-order property. What other property does T need to satisfy in order to be a heap?

R-9.3) Hint Use a simple list-based priority queue and a pencil with a good eraser.

R-9.3) Solution (1, D), (3, J), (4, B), (5, A), (2, H), (6, L).

R-9.4) Hint There is a very good reason this exercise appears in this chapter.

R-9.4) Solution The best data structure for this air-traffic control simulation is a priority queue. The priority queue will enable the handling of the time stamps and keep the events in order so that the event with the smallest time stamp is extracted easily.

R-9.5) Hint Be prepared!

R-9.5) Solution Keep an additional variable that references the current minimum entry. This allows min to run in O(1) time. Note that removeMin will still require O(n) time; although the current min can be easily found and removed, that method must look through all remaining elements to identify the new minimum.

R-9.6) Hint Sounds too good to be true.

R-9.6) Solution See previous solution.

R-9.7) Hint Mimic the illustration style used in the book.

R-9.7) Solution

47 22 15 36 44 10 3 9 13 29 25 3 15 36 44 10 22 9 13 29 25 3 9 36 44 10 22 15 13 29 25 3 9 10 44 36 22 15 13 29 25 3 9 10 13 36 22 15 44 29 25 3 9 10 13 15 22 36 44 29 25 3 9 10 13 15 22 36 44 29 25 3 9 10 13 15 22 25 44 29 36 3 9 10 13 15 22 25 29 44 36 3 9 10 13 15 22 25 29 36 44 R-9.8) Hint Mimic the illustration style used in the book.

R-9.8) Solution 22 15 36 44 10 3 9 13 29 25 15 22 36 44 10 3 9 13 29 25 15 22 36 44 10 3 9 13 29 25 10 15 22 36 44 3 9 13 29 25 3 10 15 22 36 44 9 13 29 25 3 9 10 15 22 36 44 13 29 25 3 9 10 13 15 22 36 44 29 25 3 9 10 13 15 22 29 36 44 25 3 9 10 13 15 22 25 29 36 44 R-9.9) Hint Think about where insertion-sort has to put each added element and design your sequence so that insertion-sort has to put each next element as far as possible.

R-9.9) Solution A worst-case sequence for insertion-sort would be one that is in descending order of keys, e.g., 44 36 29 25 22 15 13 10 9 3.

With this sequence, each element will first be moved to the front and then moved back in the sequence incrementally, as every remaining is processed. Thus, each element will be moved n times. For n elements, this means at a total of n2 times, which implies Ω(n2 ) time overall.

R-9.10) Hint Where might the second smallest key be?

R-9.11) Hint If the smallest is at the top of the heap...

R-9.11) Solution The largest key in a heap may be stored at any external node.

R-9.12) Hint The answer can be found in Section 9.2.2.

R-9.13) Hint Mimic the illustration style used in the book for insertionsort and selection-sort.

R-9.14) Hint Consider the heap-order property and the definition of the level number of a node in a tree.

R-9.14) Solution Yes, tree T is a heap. It is a complete binary tree and each node stores a key value greater than the key of its parent, except for the root.

48

Chapter 9. Priority Queues R-9.15) Hint Recall the definition of a complete binary tree.

R-9.15) Solution Since a heap is a complete binary tree, the levels of the heap are filled left to right. Thus, a node with the left child nay not have the right child. However, if a node has the right child, it must also have the left child.

R-9.16) Hint The answers are “yes,no,yes.” Now all you have to do is to give examples for the yeses and a reason for the no.

R-9.16) Solution With a preorder traversal, a heap that produces its entries in increasing order is that which is represented by the array list [1, 2, 5, 3, 4, 6, 7]. There does not exist a heap for which an inorder traversal produces the keys in order. This is because in a heap the parent is always less than all of its children or greater than all of its children. The heap represented by [1, 5, 2, 7, 6, 4, 3] is an example of one which produces its keys in decreasing order during a postorder traversal.

R-9.17) Hint The preorder sequence starts out 0, 1, 3, 7, ...

R-9.18) Hint Consider the last n/2 terms in this sum.

R-9.18) Solution Consider the last n/2 terms in this sum. Each one is at least log n/2 = log n − 1. Thus, this sum is at least (n/2) log n − n/2, which is O(n log n).

R-9.19) Hint Try to construct a heap that has larger elements in left subtrees.

R-9.19) Solution Imagine the heap which is represented by the array list [1, 5, 2, 8, 9, 7, 6]. This heap will not produce keys in nondecreasing order when a preorder traversal is used.

R-9.20) Hint Try to construct a heap that has larger elements in right subtrees.

R-9.20) Solution Imagine the heap which is represented by the array list [1, 5, 2, 8, 9, 7, 6]. This heap will not produce keys in nonincreasing order when a postorder traversal is used.

R-9.21) Hint Mimic the illustration style used in the book.

R-9.22) Hint Mimic the illustration style used in the book.

R-9.23) Hint You need to be very careful about how you partition the keys between the subtrees rooted at the children of the root.

R-9.24) Hint Structure the insertions so that each requires lots of downheap bubbling.

49

Creativity C-9.25) Hint Figure out a way to time stamp the entries in the priority queue.

C-9.25) Solution Maintain a variable m initialized to 0. On a push operation for element e, call insert(m, e) and decrement m. On a pop operation, call remove and increment m.

C-9.26) Hint Figure out a way to time stamp the entries in the priority queue.

C-9.26) Solution Maintain a maxKey variable initialized to 0. On an enqueue operation for element e, call insert(maxKey, e) and increment maxKey. On a dequeue operation, call removeMin. C-9.27) Hint Is it ever possible that a new element gets a key that is strictly smaller than a previously inserted element?

C-9.28) Hint Manage the array circularly.

C-9.29) Hint Do a single upward swap and recur (if necessary).

C-9.30) Hint Do a single downward swap and recur (if necessary).

C-9.31) Hint Do simple up-and-down searches in the tree to locate the last node each time.

C-9.31) Solution /∗∗ ∗ Utility called just after insert has been called. It updates 'last' ∗ reference to be an external node of a proper binary tree to expand. ∗/ private Position<E> findInsertionPosition( ) { Position<E> z; // desired insertion position if (isEmpty( )) { z = root( ); } else { z = last; // assumed reference to current last position while (!isRoot(z) && z == right(parent(z))) z = parent(z); // walk upward if (!isRoot(z)) // then go to right sibling z = right(parent(z)); while (!isExternal(z)) // and finally z = left(z); // find leftmost internal node in subtree } return z; }

50

Chapter 9. Priority Queues C-9.32) Hint Think about what changes need to be made when leaves are created or destroyed.

C-9.33) Hint Consider the binary expansion of n − 1, n, and n + 1.

C-9.33) Solution The path to the last node in the heap is given by the path represented by the binary expansion of n with the highest-order bit removed.

C-9.34) Hint Note that the entries do not need to be reported in sorted order. Use binary recursion on the subtrees of the heap and think about where the keys smaller than k are stored in the heap H. C-9.34) Solution If the root of the tree has a key value less than k, record that value and then recursively search both the left and right subtrees.

This algorithm takes O(k) time, because there is no node in H storing a key larger than k that has a descendant storing a key less than k.

C-9.35) Hint Think carefully about how location-aware entries can be implemented efficiently.

C-9.36) Hint Use calculus (or review the hint for Exercise C-4.39).

C-9.36) Solution This summation is relevant because the time for each upheap call is bounded by O(i) for a node at depth i, and there are at most 2i nodes at depth i. For an analysis of this series, see solution to Exercise C-4.39.

C-9.37) Hint Study the combine step in the bottom-up heap construction algorithm.

C-9.37) Solution Create a new node to serve as rot of T , linked to the roots of T1 and T2 as its children, and then remove a leaf from one of the trees and place its item at the new root of T . Then call downheap at that root to reestablish the heap property.

C-9.38) Hint Use a suitably constructed heap.

C-9.38) Solution Build a heap storing the frequent flyers and their mileage, using bottom-up heap construction. This takes O(n) time. Next, call removeMin log n times, which takes O(log n · log n) time, to determine the top log n flyers. Thus, the total time is O(n).

C-9.39) Hint Start by using the bottom-up construction.

C-9.40) Hint Process elements one at a time, always storing the largest k that you have seen.

C-9.40) Solution Maintain a minimum-oriented heap with maximum size k. Start by inserting the first k numbers, and from that point on, if the next number is greater than the smallest number in the heap, then remove the smallest number and then insert the new number. There will be at most 2n heap operations, each of which takes O(log k) time since the heap has at most k entries.

51 C-9.41) Hint Write a short method that computes the number of 1’s in the binary expansion of an integer by using the bitwise “and” operation.

C-9.41) Solution public class integerComparator implements Comparator<Integer> { private int countBits(int k) { int numOnes = 0; int tmp = k; while (tmp != 0) { int bit = tmp & 1; if (bit == 1) numOnes++; tmp = tmp >> 1; } return numOnes; } public int compare(Integer a, Integer b) { int valA = countBits(a); int valB = countBits(b); return (valA − valB); } } C-9.42) Hint Replace all use of operators >, <, and ==, with the appropriate call to the comparator’s compare method.

C-9.43) Hint Create a new key type internally that wraps the provided keys to invert comparisons.

C-9.44) Hint Partition the array into a sorted part and an unsorted part and use swaps to move elements around.

C-9.45) Hint Partition the array into a sorted part and an unsorted part and use swaps to move elements around.

C-9.45) Solution Note well that the insertion sort implementation given in Code Fragment 3.6 suffices (although not written for a generic type).

C-9.46) Hint Use the right portion of the array to store the heap.

C-9.47) Hint You will need two data structures that somehow keep “links” between each other.

C-9.47) Solution Unmonopoly can be played efficiently using two adaptable priority queues (with location-aware entries), one keeping track of the player with minimal amount of money and the other keeping track of the player with the most. Each turn involves pairing up the minimal and maximal elements, redistributing their wealth, and then updating their keys

Chapter 9. Priority Queues

52

(in both priority queues). These structures allow constant-time pairing of the minimal and maximal elements and fast logarithmic-time updating of keys.

C-9.48) Hint You will need two priority queues.

C-9.49) Hint Use adaptable priority queues.

Projects P-9.50) Hint Use as large of inputs as you can for experimentation.

P-9.51) Hint Experiment with for which values of k your new implementation outperforms the original.

P-9.52) Hint Decide early how you are going to implement the “pointers” for your location-aware entries.

P-9.53) Hint Mimic the animation style provided in the book.

P-9.54) Hint Use a heap for the priority queue.

P-9.55) Hint Use a heap for the CPU job priority queue.

P-9.56) Hint Study again the bottom-up heap construction algorithm.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

9

Maps, Hash Tables, and Skip Lists

Hints and Solutions Reinforcement R-9.1) Hint The first insertion is O(1), the second is O(2), ...

R-9.2) Hint Use the PositionalList.remove method to delete an entry from the map.

R-9.3) Hint Take advantage of the existing findIndex method.

R-9.3) Solution public boolean containsKey(K key) { return (findIndex(key) != −1); } R-9.4) Hint Think about which of the schemes use the array supporting the hash table exclusively and which of the schemes use additional storage external to the hash table.

R-9.5) Hint There is a lot of symmetry and repetition in this string, so avoid a hash code that would not deal with this.

R-9.5) Solution Either polynomial hash codes or cyclic shift hash codes would be good.

R-9.6) Hint Try to mimic the figure in the book.

R-9.6) Solution 0 1 2 3 4 5 6 7 8 9 10 13 94 44 12 16 20 39 88 23 5 11 R-9.7) Hint Try to mimic the figure in the book.

R-9.7) Solution 0 1 2 3 4 5 6 7 8 9 13 94 39 16 5 44 88 11 12 23

10 20

45

0

R-9.8) Hint The failure occurs because no empty slot is found. For the drawing, try to mimic the figure in the book.

R-9.8) Solution 0 1 2 3 4 5 6 7 8 9 10 13 94 39 11 44 88 16 12 23 30 The probe sequence when inserting value 5 fails to ever find the sole remaining empty slot (at index 4).

R-9.9) Hint Try to mimic the figure in the book.

R-9.9) Solution 0 1 2 3 4 5 6 7 8 9 10 13 94 23 88 39 44 11 5 12 16 20 R-9.10) Hint Think of the worst-case time for inserting every entry in the same cell in the hash table.

R-9.10) Solution The worst-case time is O(n2 ). The best case is O(n).

R-9.11) Hint Mimic the way the figure is drawn.

R-9.11) Solution 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 12 18 41 30 36 25 54 38 10 28 R-9.12) Hint Combine the hash values of the two components to make a hash value for the pair.

R-9.12) Solution public int hashCode( ) { return (a.hashCode( ) ˆ b.hashCode( )); } public boolean equals(Object o) { if (o == null) return false; if (getClass( ) != o.getClass( )) return false; Pair other = (Pair) o; return (a.equals(other.a) && b.equals(other.b)); } R-9.13) Hint There is a subtle flaw—but can you find it?

R-9.13) Solution The problem occurs if null is allowed as a value within the map. In that case, there is ambiguity when bucket.remove(k) returns null, as that may indicate that nothing was removed, or that a key was removed having null as its value. Therefore, we might need to decrease n, even when null is returned.

R-9.14) Hint The load factor can be controlled from within the abstract class, but there must be means for setting the parameter (either through the constructor, or a new method).

17

18

46

Chapter 9. Maps, Hash Tables, and Skip Lists R-9.15) Hint It is okay to insert a new entry on “top” of the deactivated entry object.

R-9.16) Hint You will need to keep track of the number of probes in order to apply quadratic probing.

R-9.17) Hint Think of where the entry with minimum key is stored.

R-9.18) Hint Since the map will still contain n entries at the end, you can assume that each remove( ) operation takes the same asymptotic time.

R-9.19) Hint Take advantage of the existing findIndex method.

R-9.19) Solution public boolean containsKey(K key) { int j = findIndex(key); return (j < table.size( ) && compare(key, table.get(j)) == 0); } R-9.20) Hint The crucial methods are get and put.

R-9.21) Hint In the new code, what happens when key equals table.get(mid)?

R-9.21) Solution This version is certainly wrong. This can be seen by considering for example a call of findIndex(20, 0, 2) for a table with contents {10, 20, 30}. Such a call should return index 1, yet the newly proposed code will return index 3.

It is worth noting that the alternate version would produce the correct result if only line 4 had been written as if (compare(key, table.get(mid)) <= 0) thereby grouping the equal case with the if clause (not the else clause).

R-9.22) Hint Assume that a skip list is used to implement the sorted map.

R-9.22) Solution For this problem, we assume we are using a skip list as the implementation for the sorted map. (If a SortedTableMap were used, with lower price/performance pairs, each pair is inserted at the beginning of the array list, and thus the insertion time dominates the search time, for overall O(n2 ) time.)

With a skip list, the expected running time for maintaining a maxima set if we insert n pairs such that each pair has lower price and performance than one before it is O(n log n), since each pair is inserted and does not remove any others. Thus, the i th insertion runs in O(log i) time, and the total expected running time is ∑ni=1 log i, which is O(n log n).

If, on the other hand, each pair had a lower price and higher performance than the one before it, then the overall running time is O(n), because each new pair causes the removal of the pair that came before it. Therefore the size of the map is constant, and thus all its operations run in expected O(1) time.

47 R-9.23) Hint Mimic the style of the figures in the book.

R-9.24) Hint You must link out the removed entry’s tower from all the lists it belongs to.

R-9.25) Hint Compare to the implementation of the addAll method given in Section 10.5.1.

R-9.25) Solution Loop through the second set, while removing each of its elements from the first set (if it exists).

R-9.26) Hint Compare to the implementation of the addAll method given in Section 10.5.1.

R-9.26) Solution Loop through the first set, and remove each element that cannot be found in the second set.

R-9.27) Hint Recall that most skip-list operations run in O(log k) time for a set with size k.

R-9.27) Solution O(m log(n + m)) time.

R-9.28) Hint Recall that most hash-table operations run in O(1) expected time.

R-9.28) Solution O(m) R-9.29) Hint Recall that most hash-table operations run in O(1) expected time.

R-9.29) Solution O(m) R-9.30) Hint Recall that most hash-table operations run in O(1) expected time.

R-9.30) Solution O(n) R-9.31) Hint Something from this chapter should be helpful!

R-9.31) Solution We should use a sorted multiset, as we want to maintain multiple entries with the same birthday and we want to be able to do neighboring queries.

Creativity C-9.32) Hint Consider a bootstrapping method for finding the primes up √ to 2M. C-9.33) Hint Your solution should make a single call to findIndex.

C-9.33) Solution

48

Chapter 9. Maps, Hash Tables, and Skip Lists public V putIfAbsent(K key, V value) { int j = findIndex(key); if (j == −1) { table.add(new MapEntry<>(key, value)); return null; } else { return table.get(j).getValue( ); } }

// add new entry

// return existing value

C-9.34) Hint You may assume that such a method is supported by the auxiliary UnsortedTableMap C-9.35) Hint You must only call the findSlot utility once.

C-9.36) Hint Model your solution after the existing support for other map methods.

C-9.37) Hint You may assume that such a method is supported by the auxiliary UnsortedTableMap C-9.38) Hint The heart of the process can be performed by the findSlot utility.

C-9.39) Hint When might the load factor fall below the threshold, and how can you detect this from within AbstractHashMap? C-9.40) Hint Start by defining an appropriate subclass of AbstractMap.MapEntry that includes the new next field that is desired.

C-9.41) Hint You need to do some shifting of entries to close up the “gap” just made, but you should only do this for entries that need to move.

C-9.41) Solution When we remove an entry from a hash table that uses linear probing without using deleted element markers, we must ensure that any cluster of consecutively filled cells remains intact, unless no entries in that cluster after a newly introduced gap have a hash value that falls before such a gap. Assume that we wish to delete an entry stored at index j and that the cluster it belongs to goes until an empty cell at index k. For ease of exposition only, we assume k > j, thus the cluster does not wrap around the end of the array. To fill the hole in index j, we wish to find the next entry of the cluster that has a hash value h ≤ j. If no such entry exists, we may leave a hole at j. Otherwise, assume index i holds the first such entry. We move that entry to j and then we repeat the process to fill the hole that results at index i, finding the next subsequent entry of the cluster with hash value h ≤ i. Note that the entire process takes time linear in the length of the original cluster of filled cells.

49 C-9.42) Hint For part a, note that the symmetry will halve the range of possible values. For part b, note that such automatic collisions will not occur.

C-9.43) Hint Perhaps borrow techniques from the Progression hierarchy of Chapter 2, or use Java’s iterators.

C-9.44) Hint Maintain a secondary PositionalList instance that represents the FIFO order, and store positions within that list with each entry of the hash table.

C-9.45) Hint Each map entry instance should store its current index within the table.

C-9.46) Hint Each map entry instance should store its current index within the table.

C-9.47) Hint Each map entry instance should store its position within the bucket list.

C-9.48) Hint Try out some examples.

C-9.48) Solution The original version of Code Fragment 10.11 does not guarantee that it finds the leftmost occurrence when duplicates exist, because it stops searching as soon as it finds a match. For example, if the entire table was filled with duplicates, it will report the middle index.

If the version in Exercise R-9.21 had been written as intended, with the ≤ operator on line 4, then it is a correct implementation and indeed guarantees that it finds the leftmost of all duplicates.

C-9.49) Hint Do a “double” binary search.

C-9.49) Solution In order to the find the k th smallest key in the union of the keys from S and T , we can do a “double” binary search. In other words, we will begin by examining the k/2 th element in the array list S. Next, we will find the largest element in T that is less than S[k/2] by binary search. Then, we will add the indices of the elements we were examining in S and T . If the sum equals k, then the max of the two elements is our result. If the sum is greater than k, then we will do a binary search to the right (upwards) in S. If the sum is less than k, then we will do a binary search to the left (downwards) in S. This is followed once again by searching in T for largest element less than the current element in S, etc.

This method does a binary search on S which requires O(log n) “probes.”

However, for each probe of the search, it does a binary search on T which takes O(log n) time. Thus, the entire method takes O(log2 n) time.

C-9.50) Hint Dove-tail two binary searches.

C-9.51) Hint Do a lazy iteration through indices of the underlying array list.

50

Chapter 9. Maps, Hash Tables, and Skip Lists C-9.52) Hint Manage a primary iteration through all nonempty buckets, and then a secondary iteration through each element of a bucket.

C-9.53) Hint Do a lazy iteration through the nonempty cells of the table.

C-9.54) Hint Think about first sorting the pairs by cost.

C-9.54) Solution Sort the pairs by cost. Then scan this list looking at the performance values. Remove any that have performance values worse than the (unremoved) pair that came before.

C-9.55) Hint In the insertion algorithm, first repeatedly flip the coin to determine the level where you should start inserting the new entry.

C-9.56) Hint Consider augmenting each node v in a higher level with the number of missing entries in the gap from v to the next node over.

C-9.57) Hint Consider augmenting each node v in a higher level with the number of missing entries in the gap from v to the next node over.

C-9.58) Hint Think first about how you can determine the number of 1’s in any row in O(log n) time.

C-9.58) Solution To count the number of 1’s in A, we can do a binary search on each row of A to determine the position of the last 1 in that row.

Then we can simply sum up these values to obtain the total number of 1’s in A. This takes O(log n) time to find the last 1 in each row. Done for each of the n rows, then this takes O(n log n) time.

C-9.59) Hint Consider a two-pass solution, with use of an auxiliary structure.

C-9.59) Solution public void retainAll(Set<E> other) { // let's first build a list of elements to remove ArrayList<E> leaving = new ArrayList<E>( ); for (E element : this) if (!other.contains(element)) leaving.add(element); // now let's remove those elements from the set for (E element : leaving) remove(element); } C-9.60) Hint Think of describing your algorithms in terms of boolean operations on the bit vectors.

C-9.61) Hint Think of how you could transform D into L. C-9.62) Hint Consider the way subMap was implemented for SortedTableMap. C-9.62) Solution Simply do a binary search to find an element equal to k.

Then step back through the array until you reach the first element equal to

51 k. Finally, step forward through the area reporting entries until you reach the first key that is not equal to k. This takes O(log n) time for the search and then at most s time to search back to the beginning of the run of k’s and s time return all of the elements with key k. Therefore, we have a solution running in at most O(s + log n) time.

C-9.63) Hint You need some way of grouping together entries with the same key.

C-9.63) Solution Use a skip list map, with only r nodes in the bottom level, and with each of these having a secondary linked list of elements with the same key. Thus, all the query and update operations will run in O(log r) expected time, and the getAll method will run in O(log r + s) expected time.

C-9.64) Hint You need some way of grouping together elements with the same key.

C-9.64) Solution The solution is actually quite simple–just use something like the HashMultimap class given in the book, but make sure that the capacity of the underlying hash table is always O(n). Another possibility is to use a linked hash table, which keeps its entries in a linked list in addition to the hash table. Either way we would get that the entries( ) method would run in O(n) time.

Projects P-9.65) Hint The biggest challenge is detecting the case of an infinite loop.

P-9.66) Hint When searching for an existing key, make sure to consider both of the possible buckets.

P-9.67) Hint Maintain a secondary PositionalList instance that represents the FIFO order, and store positions within that list with each entry of the hash table.

P-9.68) Hint We’ve already implemented them for you; all that’s left is the experiments.

P-9.69) Hint In a Unix/Linux system, a good place to start is /usr/dict.

P-9.70) Hint It is okay to generate these phone numbers more-or-less at random.

P-9.71) Hint Sentinels can be used in place of the theoretical −∞ and +∞.

P-9.72) Hint Try to make your screen images mimic the skip list figures in the book.

52

Chapter 9. Maps, Hash Tables, and Skip Lists P-9.73) Hint You need to find some way to let the intermediate nodes in the skip list keep track of the number of elements that have been skipped over.

P-9.74) Hint For each word t that results from a minor change to s, you can test if t is in W in O(1) time.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

10

Search Trees

Hints and Solutions Reinforcement R-10.1) Hint Recall the definition of where we perform an insertion in a binary search tree.

R-10.2) Hint You will need to draw 8 trees, but they are all small.

R-10.2) Solution R-10.3) Hint You can enumerate them with pictures.

R-10.3) Solution 5 (2 w/ 1 as root, 1 w/ 2 as root, 2 w/ 3 as root).

R-10.4) Hint Try a few examples of five-entry binary search trees.

R-10.4) Solution There are several solutions. One is to draw the binary search tree created by the input sequence: 9, 5, 12, 7, 13. Now draw the tree created when you switch the 5 and the 7 in the input sequence: 9, 7, 12, 5, 13.

R-10.5) Hint Try a few examples of five-entry AVL trees.

R-10.5) Solution There are several solutions. One is to draw the AVL tree created by the input sequence: 9, 5, 12, 7, 13. Now draw the tree created when you switch the 5 and the 7 in the input sequence: 9, 7, 12, 5, 13.

R-10.6) Hint Use a loop to express the repetition R-10.6) Solution

Chapter 10. Search Trees

54

private Position<Entry<K,V>> treeSearch(Position<Entry<K,V>> p, K key) { Position<Entry<K,V>> walk = p; while (isInternal(walk)) { int comp = compare(key, walk.getElement( )); if (comp == 0) return walk; // key found; return its position else if (comp < 0) walk = left(walk); else walk = right(walk); } return walk; // unsuccessful search if this is reached } R-10.7) Hint There is one of each type. Which one is which?

R-10.7) Solution The rotation in Figure 11.11 is a double rotation. The rotation in Figure 11.13 is a single rotation.

R-10.8) Hint Mimic the figure in the book.

R-10.8) Solution The updated tree follows. The highlighted nodes (44,50,54) were involved in a trinode restructuring.

4 62

1 17

3

2

50

78

2

2

1

44

54

88

1

1

48

52

R-10.9) Hint Mimic the figure in the book.

R-10.9) Solution The updated tree follows. Not much has changed, as by our implementation, the root node takes on value 54 (the max of the left subtree), and then the node that had held 54 is removed; however, no imbalance results from that deletion. (A more significant change would have occurred had the minimum value from the right subtree been used as a replacement for 62.)

4 54 3

2

44 1 17 1 48

78 2

1

50

88

55 R-10.10) Hint Think about the data movements needed in an array list representation of a binary tree.

R-10.11) Hint Carefully note the heights of all subtrees before the deletion, and after the deletion but before the restructuring.

R-10.11) Solution

h+2 h+1 h h−1

h

z h

y h−1

x

T4 T1

p

T3

T2

(a)

h+2 h+1 h h−1

h−1

z h

y h−1

x

T1

T4 T3

T2

(b)

h+2 h+1

h y h−1

T1

x

h−1

T2

h

T3

z

h−1

T4

(c) Rebalancing of a subtree during a deletion with both children of y having the same height: (a) before the deletion of p; (b) after deletion of p but before restructuring; (c) after trinode restructuring. Note that in the end, the height of the entire subtree is unchanged, and thus no further restructuring is needed.

Chapter 10. Search Trees

56

R-10.12) Hint Carefully note the heights of all subtrees before the deletion, and after the deletion but before the restructuring.

R-10.12) Solution

h+2 h

h+1

z h j

p

h−1

y k

x

T1

T4 T2

(a)

T3

h+2 h−1

h+1

z h j

T1

h−1

y k

x

T4 T2

(b)

T3

h+1 h

h x h−1

T1

z

j

k

y

h−1

T2

T3 T4 (c) Rebalancing of a subtree during a deletion with one child of y having greater height: (a) before the deletion of p; (b) after deletion of p but before restructuring; (c) after trinode restructuring. In this configuration, one of j and k must be h − 1, while the other is either h − 1 or h − 2. In either case, notice that the height of the overall subtree has been reduced by one, and therefore the imbalance might propagate upward.

R-10.13) Hint Carefully trace the potential heights of various subtrees.

R-10.13) Solution Look back at the solution we gave for the previous

57 problem, but assume that T4 has height h, such that the two children of y have the same height, yet the non-aligned one is chosen as x. The problem relates to the values of heights j and k. It may have been that j = h − 1 and k = h − 2. But in that case, after the restructuring, y is unbalanced as it would have children with heights h − 2 and h.

R-10.14) Hint Each entry is splayed to the root in increasing order.

R-10.15) Hint Use a pencil with a good eraser.

R-10.16) Hint Perform the splay operation on the lowest entry accessed for each operation.

R-10.17) Hint No. Why not?

R-10.17) Solution No. One property of a (2, 4) tree is that all external nodes are at the same depth. The multiway search tree of the example does not adhere to this property.

R-10.18) Hint It is not k1 . Why? R-10.18) Solution The key k2 would be stored at w’s parent in this case.

This is done in order to maintain the order of the keys within the tree. By storing k2 at w’s parent, all of the children would still be ordered such that the children to the left of the key are less than the key and those to the right of the key are greater than the key.

R-10.19) Hint You will need at list five entries to find a counterexample.

R-10.19) Solution First, consider the insertion order 4, 6, 12, 15, 3, 5, which results in tree (as shown in Figure 11.26j): 5 12

3 4

6

15

Next, consider the insertion order 12, 3, 6, 4, 5, 15, which produces tree: 6

3 4 5

12 15

R-10.20) Hint Use the correspondence rules described in the chapter.

R-10.21) Hint Use a pencil with a good eraser.

R-10.21) Solution There is a (2, 4) tree with 4 internal nodes having height 2, with keys {4, 8, 12} stored at the root, and four children, each holding 3 more keys. There is also a (2, 4) tree with 15 internal nodes, effectively a perfectly balanced binary tree (8 is at the root).

Chapter 10. Search Trees

58

R-10.22) Hint Use a pencil with a good eraser.

R-10.22) Solution Based on our algorithm descriptions, the results are: 10 22

1 2 5

12 16 18

30 45 50

16 5 2 1

22 10

18 12

45 30

50

R-10.23) Hint Consider looking at the (2,4) tree and red-black tree definitions again.

R-10.24) Hint Some have O(log n) worst-case height and some have O(n) worst-case height. Make sure you know which. Also, try to get the constant factors right in this case.

R-10.24) Solution a. The worst-case height for a binary search tree is n. b. Based on the book’s analysis, the AVL tree certainly has height no bigger than 2 log2 n. A tighter analysis shows that it is at most 1.44 log2 n. c. A splay tree could have height n d. A (2, 4) tree could have worst-case height of log2 n. e. A red-black tree could have worst-case height 2 log2 n.

R-10.25) Hint You need to create a node that does not satisfy the AVL balance condition, but would be acceptable in a red-black tree. A good example would be a tree with at least 6 nodes, but no more than 16.

R-10.26) Hint Case 2 is the only one that is repeated.

R-10.26) Solution Recall that an insertion begins with a downward search, the creation of a new leaf node, and then a potential upward effort to remedy a double-red violation. There may be logarithmically many recoloring operations due to an upward cascading of Case 2 applications, but a single application of the Case 1 action eliminates the double-red problem with a trinode restructuring. Therefore, at most one restructuring operation is needed for a red-black tree insertion.

59 R-10.27) Hint Case 2 is the only one that might be applied more than once.

R-10.27) Solution A deletion begins with the standard binary searchtree deletion algorithm, which requires time proportional to the height of the tree; for red-black trees, that height is O(log n). The subsequent rebalancing takes place along an upward path from the parent of a deleted node.

We considered three cases to remedy a resulting double black. Case 1 requires a trinode restructuring operation, yet completes the process, so this case is applied at most once. Case 2 may be applied logarithmically many times, but it only involves a recoloring of up to two nodes per application.

Case 3 requires a rotation, but this case can only apply once, because if the rotation does not resolve the problem, the very next action will be a terminal application of either Case 1 or Case 2.

In the worst case, there will be O(log n) recolorings from Case 2, a single rotation from Case 3, and a trinode restructuring from Case 1.

Creativity C-10.28) Hint Recall the definition of a binary search tree, in general.

C-10.29) Hint The method is similar to priority-queue sorting.

C-10.30) Hint Review what it means for splay trees to have O(log n) amortized time performance.

C-10.30) Solution Yes, splay trees can sort in O(n log n) time in the worst case: just insert all the elements and then do an inorder traversal of the splay tree. This runs in worst-case O(n log n) time because each individual insert operation runs in O(log n) amortized time and there are n insertions.

C-10.31) Hint The goal is to perform a single tree search.

C-10.32) Hint Show that O(n) rotations suffice to convert any binary tree into a left chain, where each internal node has an external right child.

C-10.33) Hint Where might the search path for k diverge from a path to one of the other keys?

C-10.33) Solution For the sake of contradiction, assume that an unsuccessful search for key k does not pass through the node with key k′ which is the greatest key less than k. Note that if k′ were modified to make it equal to k, the tree must still be a valid binary search tree, as this modification does not change the outcome of any comparison between two keys.

Furthermore, a search for k in this modified tree must follow the same path, since we assume that path did not pass through the node with k′ and thus all comparisons in the search are unchanged. Yet in this case, the

Chapter 10. Search Trees

60

search does not find k; this violates the original correctness of the binary tree search algorithm. The rest of the argument is symmetric.

C-10.34) Hint Consider the maximum number of times the recursive method is called on a position that is not within the subrange.

C-10.35) Hint Consider a top-down recursive approach.

C-10.36) Hint Make sure that the result is a valid AVL tree.

C-10.37) Hint Note that this method returns a single integer, so it is not necessary to visit all s entries that lie in the range. You will need to extend the tree data structure, adding a new field to each node.

C-10.37) Solution For each node of the tree, maintain the size of the corresponding subtree, defined as the number of internal nodes in that subtree. While performing the search operation in both the insertion and deletion, the subtree sizes can be either incremented or decremented. During the rebalancing, care must be taken to update the subtree sizes of the three nodes involved (labeled a, b, and c by the restructure algorithm).

To calculate the number of nodes in a range (k1 , k2 ), search for both k1 and k2 , and let P1 and P2 be the associated search paths. Call v the last node common to the two paths. Traverse path P1 from v to k1 . For each internal node w 6= v encountered, if the right child of w is in not in P1 , add one plus the size of the subtree of the child to the current sum. Similarly, traverse path P2 from v to k2 . For each internal node w 6= v encountered, if the left child of w is in not in P2 , add one plus the size of the subtree of the left to the current sum. Finally, add one to the current sum (for the key stored at node v).

C-10.38) Hint How do the rebalancing actions affect the information stored at each node?

C-10.38) Solution Whenever a rotation is performed, the sizes of the two affected subtrees must be recalculated. This can be implemented within TreeMap.rotate, so that the support is inherited by any of our balanced tree subclasses.

C-10.39) Hint Use triangles to represent subtrees that are not affected by this operation, and think of how to cascade the imbalances up the tree.

C-10.39) Solution

61

✗✔

✖✕ ✁ ❅ ✁ ❅ ✁ ❅ ✗✔ ✗✔ ✁ ❅ ✖✕

✖✕ ❅ ✁ ❅ ✁ ❅ ✗✔ ✁ ✗✔ ❅ ✁ ✖✕

✖✕ ❅ ✁ ❅ ✁ ❅ ✗✔ ✁ ✗✔ ❅ ✁

✖✕ ✖✕ ✄ ❈ ❊✆ ✄ ❈ ✆❊ ❈ ✄ ✗✔ ✗✔ ✆❊ ✆❊ ✆ ❊ ✖✕ ✖✕ ✆ ❊ ✄ ❈ ✆ ❊ ✄ ❈ ✆ ✄ ❈ ❊ ✗✔ ✗✔ ✆ ❊ ✆ ❊ ✖✕ ✖✕ ✆ ❊ ✆ ❊ ✆ ❊ ✆ ❊ ❊ ✆

C-10.40) Hint Study closely the balance property of an AVL tree and the rebalance operation. Also, make a node high up in tree have its AVL balance depend on the node that just got inserted.

C-10.41) Hint Study closely the balance property of an AVL tree and the rebalance operation.

C-10.42) Hint Think carefully about how the balance of a node and its ancestors changes immediately after an insertion or deletion.

62

Chapter 10. Search Trees C-10.43) Hint Just consider the operations that could change the leftmost position or who points to it.

C-10.44) Hint How do the rebalancing actions affect the minimum?

C-10.44) Solution No changes are necessary. Rebalancing does not affect which node contains the smallest key.

C-10.45) Hint These operations will be easier if you know the size of each subtree.

C-10.46) Hint Is it possible for an splay tree to also be a red-black tree?

C-10.47) Hint Find the right place to “splice” one tree into the other to maintain the (2,4) tree property. Also, it is okay to destroy the old versions of T and U .

C-10.47) Solution Assume that T and U have heights ht and hu and ht > hu . Remove the smallest entry from U . Insert this entry into the rightmost node of tree T at height ht − hu − 1. Link this node to the root of tree U .

The remove operation on U takes O(log m) time and the insert operation on T takes O(log n) time.

C-10.48) Hint Search down for k and cut along this path. Now consider how to “glue” the pieces back together in the right order.

C-10.49) Hint You don’t need to use induction here.

C-10.50) Hint Think about a way of using the structure of the binary search tree itself to indicate color.

C-10.50) Solution Since the nodes store keys in order, when keys are distinct, we can detect when the children’s subtrees are swapped. This indication can be used to mark nodes as red. Detecting this indication increases the search and update times by a constant factor, but the asymptotic running times remain the same.

C-10.51) Hint Consider the red and black meaning of the three possible balance factors in an AVL tree.

C-10.51) Solution All nodes should initially be black. If a node is black and it’s left and right sub trees have different heights, the node should be colored red (excluding the root).

C-10.52) Hint Since you know the node x will eventually become the root, maintain a tree of nodes to the left of x and a tree of nodes to the right of x, which will eventually become the two children of x.

C-10.53) Hint The analysis in the book works also for half-splay trees, with minor modifications.

C-10.54) Hint If you are having trouble with this problem, you may wish to gain some intuition about splay trees by “playing” with an interactive splay tree program on the Internet.

63

Projects P-10.55) Hint One of the biggest challenges is what to do for an unsuccessful tree search.

P-10.56) Hint Consider having an entry instance keep a reference to the node at which it is stored.

P-10.57) Hint We’ve provided the implementations; you need to develop the experiment.

P-10.58) Hint In this case, you will need a skip list implementation to test.

P-10.59) Hint The order is implicit in the tree, so adding these methods should not be hard.

P-10.60) Hint Use a recursive method to do the conversion.

P-10.61) Hint The most significant challenge is how to handle the insertion of duplicate, given that the original tree search will stop when it finds the existing key.

P-10.62) Hint Review the cases for zig-zag, zig-zig, and zig. Make sure you do splaying right before doing anything else.

P-10.63) Hint First figure out a way that works assuming that all keys in existing mergeable heaps are distinct, and then work out how this is not strictly necessary.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

11

Sorting and Selection

Hints and Solutions Reinforcement R-11.1) Hint Argue in more detail about why the merge-sort tree has height O(log n).

R-11.1) Solution For each element in a sequence of size n there is exactly one exterior node in the merge-sort tree associated with it. Since the merge-sort tree is binary with exactly n exterior nodes, we know it has height ⌈log n⌉.

R-11.2) Hint Recall the definition of a recursion trace from Chapter 5.

R-11.2) Solution The downward arrows represent a recursive call of mergesort. The upward arrows represent the return of a recursive call.

R-11.3) Hint Consider “padding” out the input with infinities to make n a power of 2. How does this affect the running time?

R-11.4) Hint Consider an input with duplicates.

R-11.4) Solution It is not stable. Given equality of S1[i] and S2[j], it makes S2[j] the next element of the result. This could easily be fixed.

R-11.5) Hint Consider an input with duplicates.

R-11.5) Solution It is not stable. Given equality of S1.first() and S2.first(), it chooses S2.first() as the next element of the result. This could easily be fixed.

R-11.6) Hint You need a different way to handle the equal case in the merge procedure.

R-11.7) Hint Consider using something like the merge for merge-sort.

R-11.7) Solution Merge sequences A and B into a new sequence C (i.e., call merge(A, B,C)). Do a linear scan through the sequence C removing all duplicate elements (i.e., if the next element is equal to the current element, remove it).

R-11.8) Hint Use a process very similar to the merge, but removing elements from one sequence as indicated.

65 R-11.9) Hint Derive a recurrence equation for this algorithm assuming n is a power of 2. Does it look familiar? It should.

R-11.9) Solution O(n log n) time.

R-11.10) Hint You want each choice of pivot to form a very bad split.

R-11.10) Solution The sequence should have the property that the selected pivot is the largest element in the subsequence. This is to say that if G contains no elements, the worst-case Ω(n2 ) bound is obtained.

R-11.11) Hint To gain intuition, work out the first few splits on the sequence (1, 1, 1, 1, 1, 1, 1, 1, 1).

R-11.11) Solution The implementation of quickSortInPlace in the Sixth Edition runs in worst-case O(n log n) time on a sequence of identical values, and expected O(n log n) time on any sequence. This is in contrast to the algorithm description in the Fifth Edition which runs in O(n2 ) on a sequence of identical values. The key difference is that in the loops scanning from left and right, the new version stop when finding equal elements, leading to a more even split.

R-11.12) Hint Recall what is the best possible split we can get for a given pivot and then derive a recurrence equation assuming we get this kind of a split. This equation should look familiar.

R-11.13) Hint Clearly the flaw must involve a case where a pass of the outermost loop completes with the value of left precisely equal to right.

R-11.13) Solution Note that within the loop, just after swapping two elements, left is incremented and right is decremented before retesting the loop condition. The flaw is that if the loop were to be exited when left == right, the element currently at S[left] has not been examined. Just outside the loop, we conclude by swapping the pivot element S[b] with the element at S[left]. This may cause an element that is smaller than the pivot to be placed in the right side. As a counterexample, consider original contents {40, 10, 20, 30}. 30 is the pivot value. During the first pass of the loop S[0] and S[2] are swapped and then left and right both become 1. If the outermost loop is exited, we conclude by swapping S[1] and S[3], resulting in contents {20, 30, 40, 10}. Although the recursive call will invert 40 and 10, 10 will remain to the right of 20 and 30. As a minimal counterexample, notice that if sorting the contents {5, 6}, the outerloop never executes, yet the values 6 and 5 become swapped after the loop.

R-11.14) Hint Develop a test case in which left equals right immediately prior to the evaluation of line 14.

R-11.14) Solution If left == right immediately after the inner loops complete, it is not that we need the values of S[left] and S[right] swapped; but what is important is that left++ and right−− are executed, or else we

66

Chapter 11. Sorting and Selection will be stuck in an infinite loop within the outerloop. As a counterexample, simply consider input {30, 20}.

R-11.15) Hint Define size group i to be those subproblems with size greater than (3/4)i+1 n and at most (3/4)i n.

R-11.15) Solution Warning: the “size group” analysis existed in the Fifth Edition, but is no longer presented in the Sixth Edition.

In order for x to belong to more than i subproblems in size group i, x has to belong to i subproblems with bad calls. This event occurs with probability 1/22 log n = 1/n2 for i = 2 log n.

R-11.16) Hint What is the maximum number of external nodes that a binary tree of height n can have?

R-11.16) Solution 2n .

R-11.17) Hint Recall that to sort n elements with a comparison-based algorithm requires Ω(n log n) time.

R-11.17) Solution k must be O(n/ log n).

R-11.18) Hint No. Why not?

R-11.18) Solution No. Bucket-sort does not use a constant amount of additional storage. It uses O(n + N) space.

R-11.19) Hint Work out some examples with triples first. Then move on to d-tuples.

R-11.19) Solution Perform the stable bucket sort on m, l, and then k. In general, perform the stable bucket sort on kd down to k1 .

R-11.20) Hint The two running times are not the same.

R-11.20) Solution Merge-sort takes O(n log n) time, as it is oblivious to the case when there are only two possible values. On the other hand, the way we have defined quick-sort with a three-way split implies that using quick-sort to sort S will take only O(n) time.

R-11.21) Hint There are only two possible key values.

R-11.21) Solution O(n) time.

R-11.22) Hint Try to mimic the partition method used in the in-place quick-sort algorithm.

R-11.22) Solution Imagine that we color the 0’s blue and the 1’s red. Start with a marker at the beginning of the array and one at the end of the array. While the first marker is at a blue element, continue incrementing its index. Likewise, when the second marker is at a red element, continue decrementing its index. When the first marker has reached a red element and the second a blue element, swap the elements. Continue moving the markers and swapping until they meet. At this point, the sequence is ordered. With three colors in the sequence, we can order it by doing the above algorithm twice. In the first run, we will move one color to the

67 front, swapping back elements of the other two colors. Then we can start at the end of the first run and swap the elements of the other two colors in exactly the same way as before. Only this time the first marker will begin where it stopped at the end of the first run.

R-11.23) Hint Check out the discussion comparing the various sorting algorithms.

R-11.23) Solution An input list that is already sorted will cause mergesort and heap-sort to take O(n log n) time to sort, but can be sorted by insertion-sort in O(n) time. If we reverse this list, then merge-sort and heap-sort still take O(n log n) time, but insertion-sort will take O(n2 ) time.

R-11.23) Hint Check out the discussion comparing the various sorting algorithms.

R-11.23) Solution An input list that is already sorted will cause .

R-11.24) Hint Consider the complexity of comparisons versus using elements as indices into an array.

R-11.25) Hint Think of the worst possible way to choose pivots in this algorithm.

Creativity C-11.26) Hint Sort first.

C-11.26) Solution First we sort the objects of A. Then we can walk through the sorted sequence and remove all duplicates. This takes O(n log n) time to sort and n time to remove the duplicates. Overall, therefore, this is an O(n log n)-time method.

C-11.27) Hint Merge-sort is a particularly good choice for a linked list.

C-11.28) Hint How do you know S and T have the same elements in them?

C-11.29) Hint Can you adapt the merge algorithm of Code Fragment 12.3 to directly manipulate nodes of the list.

C-11.30) Hint A queue of queues can be very helpful.

C-11.31) Hint It would be easier if the last element in the array were still the pivot...

C-11.32) Hint For the overall worst case, recall the worst case for choosing the last element as the pivot.

C-11.32) Solution This pivot should be a good one, since the median of these d values has a better chance of being close to the true median than the last element in the input had by itself. Still, the worst-case running time is still not so great: O(n2 /d), which is still O(n2 ) for constant d.

Chapter 11. Sorting and Selection

68

C-11.33) Hint You need to use an induction hypothesis that T (n) ≤ cn log n, for some constant c.

C-11.33) Solution We will show that T (n) ≤ cn log n, for some constant c > 0, by induction (Section 4.4.3).

By the definition of good and bad calls (and their respective worst-case partitions), as well as the linearity of expectation, 1 1 (T (3n/4) + T (n/4)) + (T (n − 1)) + bn, 2 2 where bn is the amount of time needed to do the nonrecursive work of splitting a list into sublists and concatenating the final sorted sublists. Applying our induction hypothesis, we can write

1 3n 3n n n 1 T (n) ≤ c log + c log + [c(n − 1) log(n − 1)] + bn 2 4 4 4 4 2

1 3n 3n n n 1 ≤ c log + c log + cn log n + bn 2 4 4 4 4 2

1 3n 3n 4 n n 1 = c log n − c log + c log n − c log 4 + cn log n + bn 2 4 4 3 4 4 2 = cn log n − c(3n/8) log(4/3) − c(n/8) log 4 + bn ≤ cn log n, T (n) ≤

if c ≥ 4. Thus, the expected running time of randomized quick-sort is O(n log n).

C-11.34) Hint Carefully consider how to maintain the stated invariant when classifying one additional element.

C-11.35) Hint Sort the votes, and then determine who received the maximum number of votes.

C-11.35) Solution First sort the sequence S by the candidate’s ID. Then walk through the sorted sequence, storing the current max count and the count of the current candidate ID as you go. When you move on to a new ID, check it against the current max and replace the max if necessary.

C-11.36) Hint Think of a data structure that can be used for sorting in a way that only stores k elements when there are only k keys.

C-11.36) Solution In this case we can store candidate ID’s in a balanced search tree, such as an AVL tree or red-black tree, where in addition to each ID we store in this tree the number of votes that ID has received. Initially, all such counts are 0. Then, we traverse the sequence of votes, incrementing the count for the appropriate ID with each vote. Since this data structure stored k elements, each such search and update takes O(log k) time. Thus, the total time is O(n log k).

69 C-11.37) Hint Shoot for an O(n) expected running time.

C-11.38) Hint Develop a meaningful way to break ties during comparisons .

C-11.39) Hint Sort A and B first.

C-11.40) Hint Think of alternate ways of viewing the elements.

C-11.40) Solution To sort S, do a radix-sort on the bits of each of the n elements, viewing them as pairs (i, j) such that i and j are integers in the range [0, n − 1].

C-11.41) Hint Find a way of sorting them as a group that keeps each sequence contiguous in the final listing.

C-11.42) Hint Sort first.

C-11.42) Solution Sort the elements of S, which takes O(n log n) time.

Then, step through the sequence looking for two consecutive elements that are equal, which takes an additional O(n) time. Overall, this method takes O(n log n) time.

C-11.43) Hint Try to modify the merge-sort algorithm to solve this problem.

C-11.44) Hint Try to modify the insertion-sort algorithm to solve this problem.

C-11.45) Hint Note that half of the elements ranked in the top half of a sorted version of S are expected to be in the first half of S. C-11.45) Solution Note that half of the elements ranked in the top half of a sorted version of S are expected to be in the first half of S. Likewise, half of the elements ranked in the bottom half of a sorted version of S are expected to be in the second half of S. These two sets define (n/4)(1 + n/4)/2 inversions, which is Omega(n2 ).

C-11.46) Hint Consider the graph of the equation m = a + b for a fixed value of m.

C-11.47) Hint Consider extending the generic merge algorithm.

C-11.47) Solution This can be done by creating an xorMerge class. In the xorMerge class, a method firstIsLess would insert a into C and firstIsGreater would be insert b into C. A method bothAreEqual would be null.

The resulting sequence C would be the xor of A and B. C-11.48) Hint Perform a selection first on some appropriate order statistics.

C-11.49) Hint Try to design an efficient divide-and-conquer algorithm.

C-11.49) Solution This problem can be solved using a divide-and-conquer approach. First, we choose a random bolt and partition the remaining nuts around it. Then we take the nut that matches the chosen bolt and partition

70

Chapter 11. Sorting and Selection the remaining bolts around it. We can continue doing this until all the nuts and bolts are matched up. In essence, we are doing the randomized quicksort algorithm. Thus, we have an average running time of O(n log n).

C-11.50) Hint You will need two-passes through the data at each level of recursion.

C-11.51) Hint Use in-place quick-sort as a starting point.

C-11.52) Hint Think about what would be the perfect pivot in a an algorithm like quick-sort.

C-11.53) Hint Use linear-time selection in an appropriate way.

C-11.54) Hint Think of an alien version of quick-sort.

C-11.55) Hint For (a), revisit the definition of the randomized quick-sort algorithm. For (b), argue why the probability that Ci, j (x) = 1 is at most 1/2 j and why the dependence between Ci, j (x)’s only helps. For (c), review the book’s discussion of geometric sums. For (d), just plug in the equation for µ and do the math. For (e), argue about all n elements from the bound on a single one.

C-11.55) Solution For (a), note that we need not define Ci, j for j > n, since it is impossible for an element to belong to more than n subproblems, since each subproblem at least removes the pivot.

For (b), first note that the probability that Ci, j (x) = 1 is at most 1/2 j , since in order for x to be in j + 1 subproblems in size group i it must belong to j bad calls, each of which occurs with probability 1/2. Of course, if the ( j + 1) st call for x in size group is good, then Ci,k = 0 for k > j, but this only helps, as does the case if x is not in size group i at all. Thus, ∑Li=0 ∑nj=0 Ci, j (x) ≤ ∑Li=0 ∑nj=0 Xi, j .

For (c), note that this sum is 1 + 1/2 + 1/4 + 1/8 + · · · , which is at most 2.

For (d), we note that µ = 2L; hence Pr(X > 4L) < Pr(X > 2µ) < (4/e)−µ = n (4/e)−(2−1/2 )L < (4/3)−2L = (4/3)−2 log4/3 n = 1/n2 , for n ≥ 2.

For (e), we note that the above bound implies that, for any input element x, the probability that x belongs to more than 4 log4/3 n subproblems is less than 1/n2 . Thus, the probability that any input element is in more than 4 log4/3 n subproblems is less than 1/n. Thus, the randomized quick-sort algorithm runs in O(n log n) time with probability at least 1 − 1/n.

C-11.56) Hint The recurrence equation denotes two recursive calls, but one is smaller than the other.

C-11.57) Hint If the queues currently have size k and k + 1 and a new element belongs in the bigger group, what should you do?

71

Projects P-11.59) Hint Think about how to define subproblems concisely and store them on the stack. You then can use a while loop to process problems from and to this stack. Also, please see the chapter discussion about in-place quick-sort for more hints.

P-11.60) Hint Implement the version that is not in-place first.

P-11.61) Hint An almost sorted sequence could be one with at most a linear number of inversions.

P-11.62) Hint An almost sorted sequence could be one with at most a linear number of inversions.

P-11.63) Hint Be sure to perform enough tests so that your results are trustworthy.

P-11.64) Hint Use good testing inputs to verify that your method is stable.

Also, be sure to copy the elements of the list in and out of the bucket array.

P-11.65) Hint One good animation style uses vertical lines various lengths to represent the different elements.

P-11.66) Hint Note that there are only 256 different byte values and 65536 short values.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

12

Text Processing

Hints and Solutions

Reinforcement R-12.1) Hint The empty string is one of them.

R-12.1) Solution There are four: a, aa, aaa, and the empty string.

R-12.2) Hint Recall the definitions of prefix and suffix.

R-12.2) Solution The longest prefix that is also a suffix of this string is "cgtacg".

R-12.3) Hint Mimic the style of the text-matching figures in the book.

R-12.3) Solution

73 a

a

a

b

a

a

d

a

a

b

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

R-12.4) Hint Mimic the style of the text-matching figures in the book.

R-12.4) Solution

Chapter 12. Text Processing

74 a

a

a

b

a

a

d

a

a

b

a

a

b

a

a

a

a

a

b

a

a

a

a

a a

a

a

b

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

R-12.5) Hint Mimic the style of the text-matching figures in the book.

R-12.5) Solution a

a

a

b

a

a

a

a

b

a

a

a

a

a

b

d

a

a

b

a

a

a

a

a

a

a

b

a

a

a

a

a

b

a

a

a

a

R-12.6) Hint Use the algorithm presented in the book.

R-12.7) Hint Use the version of the algorithm presented in the book.

R-12.8) Hint Mimic the drawing style used in the book.

R-12.8) Solution

75 a ✏✏ ❤PP c PP ✏ ✏ P ❤ ✏ b ❤ ❛❛ ❤ ❊ ❡ ❛❛ c ❛❛ b❊ a✓ ❆ b a ❡ b ❛ ❤ ❊❤ ❡ ✓ ❆ ❤ ❤ ❤ ❡❤ ❏ c a b❈ ☎ ✄ ❏ a a ▲ c ❏❤ ❈❤ ✄ ❤ ☎ ☎❤ ❤ ▲▲ ❤ ❊ ▲ c ✆ ❇ a✂ b❊ a✆ ❇ c a ✓ ❆c ▲▲ ✂ ❊ ✓ ❆❤ ❤ ✂ ✆ ❇❤ ❤ ❤ ❤ ❤ ❊ ✆ a✆ ❊ c ❊❤ ✆ ❤ a ☞ ☞☞ ❤ R-12.9) Hint Mimic the drawing style used in the book.

R-12.9) Solution ❤ abab c ✏✏ PPP ✏ P ✏ P ❤❤ ✏ b ❤❤ ccc ❤❤❤ ❤ ❤ ❤ ❡ bc aa ❡ aba✓ ❆ ba ❡ ✓ ❆ ❤ ❡❤ ❧ aaa☞ ▲ cc ✆ ❧c ☞☞ ▲▲ a ✆ ❧ ❧ ✆

R-12.10) Hint Mimic the drawing style used in the book.

R-12.11) Hint Don’t forget to include the space character.

R-12.12) Hint Draw the entire table for the dynamic programming algorithm.

R-12.13) Hint All answers are encoded in the table.

R-12.13) Solution Two additional common substrings are CTAATA and GTAATA. R-12.14) Hint Simulate a running of the algorithm presented in the book.

Creativity C-12.15) Hint Make the text and the pattern very periodic.

C-12.15) Solution T = “aaaaaaaaaaaaaaaaaaa”, P = “aaaab”.

C-12.16) Hint Use symmetry to redesign the search from right to left, yet still returning the index at which the pattern starts.

76

Chapter 12. Text Processing C-12.17) Hint Use symmetry to redesign the search from right to left, including the definition of the “last” map.

C-12.18) Hint Use symmetry to redesign the search from right to left, including the definition of the failure function.

C-12.19) Hint The justification is similar to the argument that the number of iterations in findKMP is O(n).

C-12.19) Solution The justification is similar to the argument that the number of iterations in findKMP is O(n).

Define k = i − j for the sake of analysis. One of the following conditions occurs at each iteration of the loop: • If P[i] = P[ j], then i increases by 1, and k does not change, since j also increases by 1.

• If P[i] 6= P[ j] and j > 0, then i does not change and k increases by at least 1, since in this case k changes from i − j to i − f ( j − 1), which is an addition of j − f ( j − 1), which is positive because f ( j − 1) < j.

• If P[i] 6= P[ j] and j = 0, then i increases by 1 and k increases by 1, since j does not change.

As a result, the number of iterations is at most 2m. Therefore, KMPFailureFunction runs in O(m) time.

C-12.20) Hint Consider modifying the KMP matching algorithm.

C-12.20) Solution Modify the KMPMatch algorithm to maintain a variable maxIndex which is the index of the longest prefix found, maxLen which is the length of the longest prefix found, and currentLen which is the length of the current prefix. Initialize all three variables to zero and modify the loop in KMPMatch as follows: • If T [i] = P[ j], increment currentLen. • If T [i] 6= P[ j] and j > 0, if currentLen > maxLen, then set maxLen = currentLen and maxIndex = i − j. In any case, reset currentLen = 0.

When the algorithm terminates, maxIndex and maxLen will hold the location and length of the longest prefix.

C-12.21) Hint Convert this problem to a noncircular pattern-matching problem.

C-12.21) Solution Generate a new text T ′ = T [n − m . . . n] + T [0 . . . m].

Run findKMP on T ′ and P. C-12.22) Hint The failure function can now take advantage of the fact that it knows what does match in the mismatched location.

C-12.23) Hint You need to incorporate a failure function with the BoyerMoore heuristics.

C-12.24) Hint Consider using a prefix trie.

77 C-12.25) Hint Start by building a suffix trie.

C-12.26) Hint Start by locating the leaf that corresponds to the end of the string.

C-12.26) Solution Locate the leaf that corresponds to the end of the string. While walking back to the root of the trie, delete every leaf encountered. The running time of this algorithm is O(s) where s is the length of the string to be deleted.

C-12.27) Hint Start by locating the leaf that corresponds to the end of the string.

C-12.28) Hint Recall how you identify the branches of the suffix trie that can be compressed.

C-12.29) Hint Create some way of visualizing your standard trie so that you can verify that it is being constructed correctly.

C-12.30) Hint Create some way of visualizing your compressed trie so that you can verify that it is being constructed correctly.

C-12.31) Hint Create some way of visualizing your prefix trie so that you can verify that it is being constructed correctly.

C-12.32) Hint Build a prefix tree for X and a suffix tree for Y .

C-12.33) Hint First give as many quarters as possible.

C-12.33) Solution First give as many quarters as possible, then dimes, then nickels and finally pennies.

C-12.34) Hint Don’t use normal denominations like you would find in a country on earth.

C-12.34) Solution If the denominations are $0.25, $0.24, $0.01, then a greedy algorithm for making change for 48 cents would give 1 quarter and 23 pennies.

C-12.35) Hint We can use a greedy algorithm.

C-12.35) Solution We can use a greedy algorithm, which seeks to cover all the designated points on L with the fewest number of length-2 intervals (for such an interval is the distance one guard can protect). This greedy algorithm starts with x0 and covers all the points that are within distance 2 of x0 . If xi is the next uncovered point, then we repeat this same covering step starting from xi . We then repeat this process until we have covered all the points in X .

C-12.36) Hint Consider using a greedy algorithm.

C-12.37) Hint You can rely on our implementation of trees and priority queues.

C-12.38) Hint Keep around extra information in the table for the dynamic programming algorithm.

Chapter 12. Text Processing

78

C-12.39) Hint Anatjari should use a greedy algorithm.

C-12.39) Solution Anatjari should use a greedy algorithm. He should draw a line between every pair of watering holes that are within k miles of one another, for he can get from one to the other with one bottle of water. Anatjari should then use a path that uses the fewest number of lines and leads from his present position to a watering hole that is within with k miles of the other side. There can be no path with fewer stops, for he is including in his minimization all pairs of watering holes that can be reached with one bottle of water.

C-12.40) Hint Review the LCS algorithm.

C-12.41) Hint There is a surprising similarity between this problem and the matrix chain-product problem.

C-12.42) Hint Use a greedy algorithm.

C-12.43) Hint Review the LCS algorithm.

C-12.44) Hint The edit distance algorithm is a dynamic program based on the LCS problem.

C-12.45) Hint Use dynamic programming.

C-12.46) Hint Use brute force, first to enumerate all pairs (a, b) such that a is in A and b is in B. C-12.47) Hint Use dynamic programming.

Projects P-12.48) Hint You can find large documents on the Internet.

P-12.49) Hint You can find large documents on the Internet.

P-12.50) Hint You can find large documents on the Internet.

P-12.51) Hint Try using inputs that are likely to cause both best-case and worst-case running times for various algorithms.

P-12.52) Hint Make sure to avoid integer overflow in your intermediate calculations when evaluating the hash function.

P-12.53) Hint Use an inverted file data structure.

P-12.54) Hint Use an inverted file data structure and store page ranks.

P-12.55) Hint Stick to the smaller strings, since LCS is a quadratic algorithm.

P-12.56) Hint On Unix/Linux systems, there is usually a list of words located at /usr/dict/words or /usr/share/dict/words.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

14

Graph Algorithms

Hints and Solutions Reinforcement R-14.1) Hint Use the drawing style of the book for the figure. ✓✏✓✏✓✏

R-14.1) Solution

✒✑✒✑✒✑ ❅ ✓✏ ❅✓✏✓✏

.

. ✒✑ ✒✑✒✑ ✓✏✓✏✓✏

.. ✒✑✒✑ ✒✑ ❅ ✓✏✓✏ ❅✓✏ .

✒✑✒✑✒✑

R-14.2) Hint Recall that an n-vertex component of a simple undirected graph can have no more than n(n − 1)/2 edges.

R-14.2) Solution If G has 12 vertices and 3 connected components, then the maximum number of edges it can have is 45. This would be a fully connected component with 10 vertices (thus having 45 edges) and two connected components each with a single vertex.

R-14.3) Hint Fix a canonical ordering of the nodes.

R-14.4) Hint Fix a canonical ordering of the nodes.

R-14.5) Hint When drawing the Euler tour notice that every in has an out.

R-14.5) Solution

66

Chapter 14. Graph Algorithms

✞ ✓✏

☎ ✓✏ ❄ ✞

B

☎ ✓✏ ❄ ✞

☎ ✓✏ ❄

✞ ✛ ✝✓✏ ✆

☎ ✓✏ ❄ ✞

☎ ✓✏ ❄ ✞

☎ ✓✏ ❄ ✛ ✝ ✆

A ☎ ✲✞✒✑ ✝ ✻

✒✑ ✝ ✻

H

✒✑ ✆ ✝ ✻

✒✑ ✆ ✝ ✻

G

C D ✲ ✞ ✒✑ ✒✑ ✆ ✝ ✆ ☎ ✻

✒✑ ✆ ✝ ✻

F

✒✑ ✆

E

The Euler tour is A → B → C → D → E → F → G → H → A → H → G → F → E → D →C → B → A R-14.6) Hint Recall the properties of inserting and removing elements in a doubly linked list.

R-14.6) Solution Inserting a vertex runs in O(1) time since it is simply inserting an element into a doubly linked list. To remove a vertex, on the other hand, we must inspect all edges. Clearly this will take O(m) time.

R-14.7) Hint Don’t forget to update the edge list E. R-14.8) Hint Don’t forget to update the edge list E. R-14.9) Hint How can the edges method be implemented?

R-14.10) Hint How can the edges method be implemented?

R-14.11) Hint The point of this exercise is to explore the trade-offs of the various representations. If you are having trouble, please review these trade-offs.

R-14.11) Solution a. The adjacency list structure is preferable. Indeed, the adjacency matrix structure wastes a lot of space. It allocates entries for 100,000,000 edges while the graph has only 20,000 edges. b. In general, both structures work well in this case. Regarding the space requirement, there is no clear winner. Note that the exact space usage of the two structures depends on the implementation details. The adjacency matrix structure is much better for operation getEdge, while the adjacency list structure is much better for operations insertVertex and removeVertex. c. The adjacency matrix structure is preferable. Indeed, it supports operation getEdge in O(1) time, irrespectively of the number of vertices or edges.

R-14.12) Hint Use a pencil and paper.

R-14.13) Hint Review the pseudocode while observing the different running times needed to implement each step when the graph is represented with an adjacency matrix.

67 R-14.14) Hint Work out an example with a complete graph of six vertices.

R-14.14) Solution The depth-first search tree of a complete graph is a path.

R-14.15) Hint Work out an example with a complete graph of six vertices.

R-14.15) Solution The breadth-first search tree of a complete graph is a star, that is, a rooted tree having all external-node children.

R-14.16) Hint Follow the algorithm descriptions and drawing styles given in the book.

R-14.16) Solution a. A drawing of graph G is given below:

2

1

① ❍❍ ❅ ❅❍❍ ❅ ❍❍ ① 6 ✟ 3 ❅① 4 ❍ ✟❍ ✟ ✟ ✟✟ ① ✟✟

7

① ❅ ❅ ❅ 8 ❅①

① ❅ ❅ ❅ 5 ❅①

b. A DFS traversal starting at vertex 1 visits the vertices in the following order: 1, 2, 3, 4, 6, 5, 7, 8. c. A BFS traversal starting at vertex 1 visits the vertices in the following order: 1, 2, 3, 4, 6, 5, 7, 8.

R-14.17) Hint Model the courses and their prerequisites as a directed graph.

R-14.17) Solution The topological sorting algorithm can help us solve this problem.

• Build a directed graph to represent the course prerequisite requirements. The nine courses are vertices in the directed graph. If a course A is a prerequisite for another course B, the directed graph has a directed edge from A to B. • Apply the topological sorting algorithm on this directed graph. The result is one possible sequence of courses for Bob. For the give set of prerequisites, the solution is not unique. For example, one possible solution is LA15, LA16, LA22, LA31, LA32, LA126, LA127, LA141, LA169. Another solution is LA15, LA16, LA127, LA31, LA32, LA169, LA22, LA126, LA141.

R-14.18) Hint Use the transitive closure algorithm given in the book.

R-14.18) Solution BOS, JFK, MIA, ORD, DFW, SFO, LAX

Chapter 14. Graph Algorithms

68

R-14.19) Hint Mimic the drawing style used in the book.

R-14.19) Solution ★ ✥ BOS

✧ ✦

❄ ✥ ★

JFK

✧ ✦

✲ ❄ ✥ ★

MIA

✧ ✦

✲ ❄ ✛ ✥ ★

✲

DFW

✧ ✦ ✻

✲❄✛ ✥ ★

ORD ✛

✧✛ ✦

✲ ✛ ✥ ★

✲

LAX ✛

✲ ✧ ✦

✲ ✛✥ ★

SFO

✧ ✦

R-14.20) Hint If you wish, you may run our implementation to determine the order.

R-14.20) Solution The edges are added as follows: BOS → SFO via JFK,

69 BOS → DFW via JFK, MIA → ORD via LAX, JFK → LAX via MIA, JFK → ORD via MIA, BOS → LAX via MIA, BOS → ORD via MIA, LAX → DFW via ORD, LAX → SFO via DFW, MIA → SFO via DFW, ORD → LAX via DFW, and ORD → SFO via DFW R-14.21) Hint Are there any pairs of vertices that are not related?

R-14.21) Solution There are n(n − 1)/2 in the transitive closure of a graph that consists of a simple directed path of n vertices (including the original edges).

R-14.22) Hint Design a counting scheme that charges each level in T with the transitive closure edges that go from that level to lower levels.

R-14.22) Solution Let us use a counting scheme that charges each level in T with the transitive closure edges that go from that level to lower levels. Note that every node in T will have transitive closure edges to all of its descendants. Thus, a node v will be the origin of as many transitive closure edges as the size of the subtree rooted at v (minus one, for v itself, but let us ignore this fact since we just have to prove an upper bound). In other words, each level of T contributes at most n edges to the transitive closure. Thus, there are O(n log n) edges in the transitive closure.

R-14.23) Hint Using the drawing style given in the book.

R-14.24) Hint The essential property of course is to observe the edge directions. So work out the pseudocode with this in mind.

R-14.25) Hint Use the drawing style given in the book, and show the order in which the edges are added to the MST. R-14.26) Hint Use the drawing style given in the book, and show the order in which the edges are added to the MST. R-14.27) Hint Use an MST algorithm.

R-14.28) Hint The black lines represent unexplored edges. What about the others?

R-14.29) Hint Edges in the DFS tree are represented by solid lines. What about the others?

R-14.29) Solution Edges in the DFS tree are represented by solid lines.

Back edges are shown with dashed lines. Forward and cross edges are shown with dashed black lines.

Chapter 14. Graph Algorithms

70

R-14.30) Hint The black lines represent unexplored edges. What about the others?

R-14.30) Solution The black lines represent unexplored edges. The blue lines represent edges leading to the discovery of a new vertex. Dashed lines represent cross edges. Thick lines represent the discovery edges at a specific depth.

R-14.31) Hint Solid black lines are edges in the original input graph.

What about the others?

R-14.32) Hint Traversed edges are shown with dashed blue lines. What about the others?

R-14.32) Solution Traversed edges are shown with dashed blue lines.

Solid black lines are untraversed edges. Thick lines show the edges traversed in the current iteration.

R-14.33) Hint Solid black edges have not been relaxed yet. What about the others?

R-14.34) Hint Edges being considered in the current iteration for the MST are shown in thick blue lines. What about the others?

R-14.34) Solution Edges being considered in the current iteration for the MST are shown in thick blue lines. Dashed lines represent rejected edges.

The cloud represents all the vertices currently in the MST. R-14.35) Hint Edges being considered in the current iteration for the MST are shown in thick blue lines. What about the others?

R-14.35) Solution Edges being considered in the current iteration for the MST are shown in thick blue lines. Dashed lines represent rejected edges.

The cloud represents all the vertices currently in the MST. R-14.36) Hint Note how much time is spent in each step of George’s algorithm.

Creativity C-14.37) Hint Make sure to remove the edge from the adjacency map for each incident vertex.

C-14.38) Hint Use a data structure described in this book.

C-14.39) Hint Suppose that such a nontree edge is a cross edge, and argue based upon the order the DFS visits the end vertices of this edge.

C-14.40) Hint The DFS method must be changed so that the repetition stops when discovering v.

C-14.41) Hint There has to be a good traversal that does this.

C-14.42) Hint Maintain a set of all vertices upon which a recursive call to DFS is currently active.

71 C-14.43) Hint Modify the DFSComplete method in order to tag each vertex with a component number when it is first discovered.

C-14.44) Hint The solution involves a traversal discussed in this chapter.

C-14.44) Solution Do a DFS of the maze, treating the branch points as vertices and the corridors as edges. If there are no back edges and every part of the maze is reachable from the start, including the finish, the maze is constructed correctly.

C-14.45) Hint Number the vertices 0 to n − 1.

C-14.45) Solution Number the vertices 0 to n − 10. Now add an edge from vertex i to vertex (i + 1) mod n, if that edge does not already exist.

This connects all the vertices in a cycle, which is itself biconnected.

C-14.46) Hint Suppose there is a forward edge or back edge and show why it would not be a nontree edge.

C-14.47) Hint Suppose there is such an edge and show why it would not be a nontree edge.

C-14.48) Hint Justify this by induction on the length of a shortest path from the start vertex.

C-14.49) Hint Take each part in turn and use induction or contradiction as justification techniques.

C-14.50) Hint Starting with the source vertex in the queue, repeatedly remove the vertex from the front of the queue and insert any of its unvisited neighbors to the back of the queue.

C-14.51) Hint Do a BFS search in G. C-14.51) Solution Construct a BFS search tree T for G. Place the vertices on even levels in X and the ones in odd levels in Y . Now double-check that there are no edges between a pair of vertices in X or a pair of vertices in Y . This algorithm runs in O(n + m) time.

C-14.52) Hint Start out greedy and patch in the places this approach misses.

C-14.53) Hint Perform “baby” searches from each station.

C-14.53) Solution For each vertex v, perform a modified BFS traversal starting a v that stops as soon as level 4 is computed.

Alternatively, for each vertex v, call method DFS(v, 4) given below, which is a modified DFS traversal starting at v: DFS(v, i) if i > 0 and v is not marked then Mark v.

Print v. for all vertices w adjacent to v do DFS(w, i − 1).

Chapter 14. Graph Algorithms

72

C-14.54) Hint Try to compute the diameter of the tree T by a pruning procedure, starting at the leaves (external nodes).

C-14.54) Solution We can compute the diameter of the tree T by a pruning procedure, starting at the leaves (external nodes). a. Remove all leaves of T . Let the remaining tree be T1 . b. Remove all leaves of T1 . Let the remaining tree be T2 . c. Repeat the “remove” operation as follows: Remove all leaves of Ti .

Let remaining tree be Ti+1 . d. When the remaining tree has only one node or two nodes, stop! Suppose now the remaining tree is Tk . e. If Tk has only one node, that is the center of T . The diameter of T is 2k. f. If Tk has two nodes, either can be the center of T . The diameter of T is 2k + 1.

C-14.55) Hint Perform a traversal of T to compute distances to leaves.

C-14.55) Solution a. (a) Remove all leaves of T . Let the remaining tree be T1 . (b) Remove all leaves of T1 . Let the remaining tree be T2 . (c) Repeat the “remove” operation as follows: Remove all leaves of Ti . Let remaining tree be Ti+1 . (d) Once the remaining tree has only one node or two nodes, stop!

Suppose now the remaining tree is Tk . (e) If Tk has only one node, that is the center of T . The eccentricity of the center node is k. (f) If Tk has two nodes, either can be the center of T . The eccentricity of the center node is k + 1. b. No! Not always unique. It’s possible that the remaining tree has two nodes. We don’t like to remove the leaves of a two-node tree (there will be nothing left!). You can try the following two trees.

The center of the first tree is D with eccentricity 2. The center of the second tree is either D or E with eccentricity 3.

A B

C

D

Tree 1

E

F

A

G

B

G C

D

E

F

H

Tree 2

C-14.56) Hint What is the in-degree of the vertex labeled i in a compact graph?

C-14.57) Hint Change the function to be optimized, but keep it indexed in terms of the a fixed listing of vertices.

73 C-14.58) Hint Think about a shortest path with negative edges.

C-14.59) Hint Be greedy.

C-14.59) Solution Initialize W to V (as a copy of all the vertices) while W is not empty Add a vertex w from W to I. Remove from W all other vertices adjacent to w.

The running time of this method is O(n + m).

C-14.60) Hint Give G lots of edges and make every edge count for lots updates in the heap.

C-14.61) Hint Examine closely the justification for why Dijkstra’s algorithm works correctly and note the place where it breaks if negative-weight edges.

C-14.62) Hint Maintain an auxiliary set of vertices that have already been discovered.

C-14.63) Hint The greedy algorithm presented in this problem is not guaranteed to find the shortest path. Why not?

C-14.63) Solution The greedy algorithm presented in this problem is not guaranteed to find the shortest path between vertices in graph. This can be seen by counterexample. Consider the weighted graph with vertices A, B, C and D, and the following edges and corresponding weights: • (A, B, 1) • (A,C, 2) • (B, D, 3) • (C, D, 1) Suppose we wish to find the shortest path from start = A to goal = D and we make use of the proposed greedy strategy. Starting at A and with path initialized to A, the algorithm will next place B in path (because (A, B) is the minimum-cost edge incident to A) and set start equal to B. The lightest edge incident to start = B which has not yet been traversed is (B, D). As a result, D will be appended to path and start will be assigned D. At this point the algorithm will terminate (since start = goal = D). In the end we have that path = A, B, D, which clearly is not the shortest path from A to D. (Note: in fact the algorithm is not guaranteed to find any path between two given nodes since it makes no provisions for backing up. In an appropriate situation, it will fail to halt.)

C-14.64) Hint Think about the important fact about minimum spanning trees.

Chapter 14. Graph Algorithms

74

C-14.65) Hint How does the number of connected components change from one iteration of Baruvka’s algorithm to the next?

C-14.66) Hint Use the tree-based union/find data structure from Chapter 10 along with one of the MST algorithms given in Chapter 12 and a good sorting algorithm.

C-14.66) Solution Use bucket-sort to sort the edges in O(m) time and then use the tree-based union/find data structure from Chapter 10 along with Kruskal’s algorithm to find the MST in O(m log∗ n) additional time (using the sorted order to determine the order in which to process the edges).

C-14.67) Hint This is not a shortest-path problem.

C-14.67) Solution We can model this problem using a graph. We associate a vertex of the graph with each switching center and an edge of the graph with each line between two switching centers. We assign the weight of each edge to be its bandwidth. Vertices that represent switching centers that are not connected by a line do not have an edge between them.

We use the same basic idea as in Dijkstra’s algorithm. We keep a variable d[v] associated with each vertex v that is the bandwidth on any path from a to this vertex. We initialize the d values of all vertices to 0, except for the value of the source (the vertex corresponding to a) that is initialized to infinity. We also keep a π value associated with each vertex (that contains the predecessor vertex).

The basic subroutine will be very similar to the subroutine Relax in Dijkstra.

Assume that we have an edge (u, v). If min{d[u], w(u, v)} > d[v] then we should update d[v] to min{d[u], w(u, v)} (because the path from a to u and then to v has bandwidth min{d[u], w(u, v)}, which is more than the one we have currently).

Algorithm Max-Bandwidth(G,a,b) a. FOR (all vertices v in V ) d[v] = 0 b. d[a] = ∞ c. Known = ∅ d. U nknown = V e. WHILE (U nknown 6= ∅) u = ExtractMax(U nknown) Known = Known ∪ {u} FOR (all vertices v in Ad j[u]) IF (min(d[u], w(u, v)) > d[v]) d[v] = min(d[u], w(u, v)) f. return (d[b])

75 Here, the method ExtractMax(U nknown) finds the node in Unknown with the maximum value of d.

Complexity (this has not been asked for): If we maintain U nknown as a heap, then there are n = |V | ExtractMax operations on it and up to m = |E| changes to the values of elements in the heap. We can implement a data structure which takes O(log n) time for each of these operations. Hence, the total running time is O((n+ m) log n).

C-14.68) Hint Use a greedy algorithm.

C-14.68) Solution Consider the weighted graph G = (V, E), where V is the set of stations and E is the set of channels between the stations. Define the weight w(e) of an edge e in E as the bandwidth of the corresponding channel.

Given below are two ways of solving the problem: a. At every step of the greedy algorithm for constructing the minimum spanning tree, instead of picking the edge having the least weight, pick the edge having the greatest weight. b. Negate all the edge-weights. Run the usual minimum spanning tree algorithm on this graph. The algorithm gives us the desired solution.

C-14.69) Hint Model this problem as an optimal path problem that goes between two vertices in a directed graph without cycles.

C-14.69) Solution Simply run the shortest-path algorithm with path(a) < path(b) if there is more gold on path(a) than path(b).

C-14.70) Hint Define an augmented graph from the input graph and perform the appropriate computation on the augmented graph.

C-14.70) Solution There are two possible solutions: a.

• For each airport ai in A, draw a circle circlei to represent the time (24 hours).

• For each flight f in F, find the origin airport ao , the destination airport ad , the departure time td , and the arrival time ta . Draw a vertex v1 on circleo marked the time td , also draw a vertex v2 on circled marked the time (ta +c(ad )). Draw an directed edge from v1 to v2 with weight ta +c(ad )-td (of course we must compute the correct weight (flight time) in case like the departure time is 10:00PM and the arrival time is 1:00AM next day). The direction of edges on a circle should be clockwise.

• Now we have a new graph like the figure below:

Chapter 14. Graph Algorithms

76 12AM

2AM

4AM

circle1

circle2

Circle3

8AM

Circle4

6PM

9PM 2PM

10PM

10AM

12PM 12PM

8Hr

10PM

10Hr Circle5

6AM

9PM Circle6

6PM 2PM 16Hr

Note that we have included the minimum connecting time in the total flight time. We can start the modified new flights without worrying about the connecting times.

Then to solve this problem is to find the shortest path from the first vertex on circlea (origin airport a) representing time t or after t to one vertex on circleb (destination airport b) in the graph. The flight sequences can be obtained from the shortest path from origin to destination. b. The following algorithm finds the minimum travel time path from airport a ∈ A to airport b ∈ A. Recall, we must depart from a at or after time t. Note, “⊕” and “ ” are operations which we must implement. We define these operations as follows: If x ⊕ y = z, then z is the point in time (with date taken into consideration) which follows x by y time units. Also, if a b, then a is a point in time which precedes or equals b. These operations can be implemented in constant time. initialize fringe to empty initialize incoming flight(x) to nil for each x in A earliest arrival time(a)=t earliest arrival time(x)=∞ for x in A where x 6= a repeat remove from fringe airport x such that earliest arrival time(x) is soonest if x 6= b then if x = a then time can depart=t else time can depart=earliest arrival time(x) ⊕ c(x) for each flight f in F such that a1 ( f ) = x if time can depart t1 ( f ) and t2 ( f ) earliest arrival time(a2 ( f )) then earliest arrival time(a2 ( f ))=t2 ( f )

77 incoming flight(a2 ( f ))= f add a2 ( f ) to the fringe if it is not yet there until x = b initialize city to b initialize f light sequence to nil while (city6= a) do append incoming f light(city) to f light sequence assign to city the departure city of incoming f light(city) reverse f light sequence and output

The algorithm essentially performs Dijkstra’s shortest-path algorithm (the cities are the vertices and the flights are the edges). The only small alterations are that we restrict edge traversals (an edge can only be traversed at a certain time), we stop at a certain goal, and we output the path (a sequence of flights) to this goal. The only change of possible consequence to the time complexity is the flight sequence computation (the last portion of the algorithm). A minimum-time path will certainly never contain more that M flights (since there are only M total flights). Thus, we may discover the path (tracing from b back to a) in O(M) time. Reversal of this path will require O(M) time as well. Thus, since the time complexity of Dijkstra’s algorithm is O(M log N), the time complexity of our algorithm is O(M log N + M + M) = O(M log N). Note: Prior to execution of this algorithm, we may (if not given to us) divide F into subsets F1 , F2 , . . . , FN , where Fi contains the flights which depart from airport i. Then when we say “for each flight f in F such that a1 ( f ) = x”, we will not have to waste time looking through flights which do not depart from x (we will actually compute “for each flight f in Fx ”).

This division of F will require O(M) time (since there are M total flights), and thus will not “slow down” the computation of the minimum time path (which requires O(M log N) time).

C-14.71) Hint If M 2 (i, j) = 1, then there is a path of length <= 2 (a path traversing at most 2 edges) from vertex i to vertex j in the graph G. Alternatively, if M 2 (i, j) = 0, then there is no such path. Now generalize from here...

C-14.71) Solution a. If M 2 (i, j) = 1, then there is a path of length <= 2 (a path traversing at most 2 edges) from vertex i to vertex j in the graph G. Alterna-

Chapter 14. Graph Algorithms

78

tively, if M 2 (i, j) = 0, then there is no such path. b. Similarly, if M 4 (i, j) = 1, then there exists a path of length <= 4 from vi to v j , otherwise no such path exists. The situation with M 5 is analogous to that of M 4 and M 2 . In general, M p gives us all the vertex pairs of G which are connected by paths of length <= p.

C-14.72) Hint The running time is more than linear.

C-14.72) Solution Karen’s algorithm sets parent pointers to the parent pointers of parents. Since the paths from a position in a tree-based partition structure go up until reaching the root, which points to itself, eventually every position will point to the root. Moreover, each time Karen makes a pass over S, she doubles the number of position each position has “linked out” of its path to the root. Thus, the running time of her algorithm is O(h log h).

Projects P-14.73) Hint Test the basic structure by having a method that visualizes the adjacency matrix.

P-14.74) Hint Test the basic structure by having a method that visualizes the edge list.

P-14.75) Hint Test the basic structure by having a method that visualizes the adjacency list.

P-14.76) Hint Implement the static undirected version first, then add the extra methods.

P-14.77) Hint Have some way of printing out each phase of the algorithm for debugging purposes.

P-14.78) Hint Look at Dijkstra’s shortest path algorithm as a model.

P-14.79) Hint Use uniform and Gaussian distributions for the edge weights.

P-14.80) Hint Use the Swing GUI components to implement the visualization.

P-14.81) Hint Do a Breadth-First Search from each node in the network.

Data Structures and Algorithms in Java™ Sixth Edition Michael T. Goodrich Department of Computer Science University of California, Irvine

Roberto Tamassia Department of Computer Science Brown University

Michael H. Goldwasser Department of Mathematics and Computer Science Saint Louis University

Instructor’s Solutions Manual

Chapter

15

Memory Management and B-Trees

Hints and Solutions Reinforcement R-15.1) Hint Perform an Internet search to determine a good estimate on the number of atoms on earth.

R-15.2) Hint Draw the memory cache and manually process the requests using a pencil with a good eraser.

R-15.2) Solution This sequence causes 5 page misses, on the first 5, second 3, second 4, third 2, and last 3.

R-15.3) Hint Draw the memory cache and manually process the requests using a pencil with a good eraser.

R-15.3) Solution This sequence causes 3 page misses, on the first 5, the last 2, and the last 3.

R-15.4) Hint Draw the memory cache and manually process the requests using a pencil with a good eraser.

R-15.5) Hint Start with the description provided in the book.

R-15.6) Hint Revisit the definition of an (a, b) tree.

R-15.6) Solution T is a valid (a, b) tree for 2 ≤ a ≤ min{5, (b + 1)/2} and b ≥ 8. For example, T could be a (4, 8) tree, a (5, 9) tree, but not a (5, 8) tree.

R-15.7) Hint The definition of an order-d deals with the minimum and maximum number of children an internal node can have. Please see the book for details.

R-15.7) Solution T could be an order-8, order-9, or order-10 B-tree.

R-15.8) Hint Use a pencil with a good eraser.

Chapter 15. Memory Management and B-Trees

80

Creativity C-15.9) Hint Review the external-memory sorting algorithm.

C-15.10) Hint Keep the top one or two blocks of the stack in main memory.

C-15.11) Hint Keep queue runs in blocks.

C-15.11) Solution Use a linked list where each node is a block of size B. We add elements to the end, using O(1) disk transfers (creating a new block when we have filled the last block). We dequeue elements from the front, returning the block to the free memory heap when it becomes empty.

C-15.12) Hint Consider an alternate linked list implementation that uses “fat” nodes.

C-15.12) Solution Consider a linked list implementation of the ADT where every node is a block of size B, holding at least B/4 entries. When an element is added to a node with a full block, that node can be split into two blocks having B/2 entries, and then the new element can be inserted.

Likewise, if an element is deleted from a block bringing its number of elements below B/4, an element can either be borrowed from a neighboring block, or else two neighboring blocks can be combined into one. Because of the requirement that a node hold at least B/4 entries, there will be at most 4n/B blocks and therefore a complete scan uses O(n/B) transfers.

C-15.13) Hint Note that each valid node v and its children in a (2,4) tree correspond to a red-black subtree of height 2. In a (4,8) tree, you will need bigger subtrees.

C-15.14) Hint Consider the extreme cases.

C-15.15) Hint Try to block order-B sized sub “trees” in the skip list.

C-15.16) Hint Start from sequence solution for the union-find problem.

C-15.17) Hint A single scan suffices.

C-15.17) Solution Sort the elements of S using an external-memory sorting algorithm. This brings together the elements with the same keys. One more scan through this sorted order matches up the red and blue elements.

The time for this algorithm is dominated by the time to sort, which can be done using O((n/B) log(n/B)/ log(M/B)) block transfers.

C-15.18) Hint Each request can “see into the future” to see when is the next time existing blocks will be accessed next.

C-15.19) Hint In an initial scan, keep track of the best candidate majority value, x, and a counter that keeps track of the number of times you have seen a copy of x versus some other integer.

81 C-15.20) Hint Consider what happens to a page that is accessed a lot and then never accessed again.

C-15.20) Solution Consider a sequence where page 1 is accessed m times and then never accessed again, and then pages 2 through m + 1 are each accessed once and then this same access sequence of pages 2 through m + 1 is repeated. The LFU algorithm will never through out page 1; hence, will have a page miss on every access, starting with page m + 1.

But an optimal algorithm will throw out page 1 and then never have any more page misses after the misses for the first time pages 2 through m + 1 are accessed.

C-15.21) Hint The answer just uses some simple logarithm identities.

C-15.21) Solution O(log n) time.

Projects P-15.22) Hint Make sure to use typical memory sizes and do a long simulation.

P-15.23) Hint Let a and b be definable parameters or constants. And let insertion be the first update method you program.

P-15.24) Hint Start with insertion as the first update operation you code up, and use a simple uniform distribution of keys to perform the experiments.