Answers to Self-Study Questions

The printInt method does obey recursion rule 1; it does have a base case, namely:

if (k == 0) return;

printInt( k - 1 );

if (k <= 0) return;

The call printTwoInts(3) causes the following to be printed:

From before recursion: 3
From before recursion: 2
From before recursion: 1
From after recursion: 1
From after recursion: 2
From after recursion: 3

Question 1: The call factorial(3) leads to three recursive calls; when all calls are still active, the runtime stack would be as shown below (showing just the values of parameter N). The values returnedby each call are also shown.

                                       Returned value
+------+                               --------------
| N: 0 |   <--- top of stack	             1
+------+
+------+
| N: 1 |                                     1
+------+
+------+
| N: 2 |                                     2
+------+
+------+
| N: 3 |                                     6
+------+

Question 2: The iterative version of factorial will return -1 as the result of the call factorial(-1). The recursive version will go into an infinite recursion (because the base case, N==0, will never be reached).

Since, mathematically, factorial is undefined for negative numbers, a call to factorial with a negative number should cause an exception. This is easily done for the iterative version:

int factorial (int N) {
  if (N < 0)throw new NegativeValueException();
  if (N == 0) return 1;
  int tmp = 1;
  for (int k=N; k>1; k--) tmp = tmp*k;
  return (tmp);
}

For the recursive version, we could change the method to:

int factorial (int N) {
  if (N < 0)throw new NegativeValueException();
  if (N == 0) return 1;
  else return (N*factorial(N-1));
}

int factorial (int N) {
  if (N < 0)throw new NegativeValueException();
  else return factAux(N);
}

int factAux(int N) {
  if (N == 0) return 1;
  else return (N*factAux(N-1));
}

Question 1:

public static int sum( Listnode L ) {
  if (L == null) return 0;
  Integer val = (Integer)L.getData();
  return val.intValue() + sum(L.getNext());
}

Question 2:

public static String vowels(String S) {
  // Added base case
  if (S.length() == 0) {
     return "";
  }

  String ch = S.substring(0,1);
  if (ch.equals("a") || ch.equals("e") || ch.equals("i")
      || ch.equals("o") || ch.equals("u")) {
    return ch + vowels(S.substring(1));
  } else {
    return vowels(S.substring(1));
  }
}

N	T(N)
1	1
2	3
4	7
8	15

The solution is: T(N) = 2*N-1

Here's the verification:

T(N)	=	1 + 2 * T(N/2)	// given
2*N-1	=?=	1 + 2 * (2 * (N/2) - 1)	// replace T(...) on both sides with the guessed solution in which each N is replaced by ...
2*N-1	=?=	1 + 2 * (N - 1)	// simplify
2*N-1	=?=	1 + 2*N - 2	// simplify more
2*N-1	=	2 * N - 1	// yes the two sides are equal!