Recursive Void Methods and the Leap of Faith

1. Recursive Void Methods and the Leap of Faith

Title

Think Java 2e · Chapter 8 · Recursive Methods

Sections 8.1-8.4 · pp. 127-134

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 8 (Recursive Methods), Sections 8.1-8.4, pp. 127-134. Everything on these slides can be checked against those pages.

1. Write a recursive void method with a base case and a recursive call.

2. Draw the stack diagram for a recursive call and identify the base case frame.

3. Explain what causes a StackOverflowError and how a base case prevents it.

4. Translate a recursive mathematical definition directly into a Java method.

5. Trace a value-returning recursive method, following return values back up the stack.

6. Apply the leap of faith: assume the recursive call works, and check only the step you are writing.

• 8.1 — Recursive Void Methods
• 8.2 — Recursive Stack Diagrams
• 8.3 — Value-Returning Methods
• 8.4 — The Leap of Faith

3. Retrieve before you read

Warm-up

One picture from Chapter 4 is about to do much more work than it did there.

4. A method that invokes itself

Concept

Up to now we have used loops whenever we needed to repeat something; methods that use iteration are called iterative. They are straightforward, but sometimes more elegant solutions exist. This chapter explores one of the most magical things a method can do: invoke itself to solve a smaller version of the same problem.

• 8.1 — recursive void methods: countdown and nLines
• 8.2 — the stack diagram, the base case, and StackOverflowError
• 8.3 — value-returning recursion: factorial from its definition
• 8.4 — the leap of faith, and Fibonacci

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 8 (Recursive Methods), Sections 8.1-8.4, pp. 127-134 — Chapter 8 opens on printed page 127.

5. Recursive void methods

Section

Section 8.1

6. countdown calls countdown

Concept

A method that invokes itself is called recursive. This one takes a single integer: if it is 0, it displays Blastoff!; otherwise it displays the number and then invokes itself, passing n - 1.

public static void countdown(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        System.out.println(n);
        countdown(n - 1);
    }
}

iterative — A method or algorithm that repeats steps by using one or more loops.

recursive — A method or algorithm that invokes itself one or more times with different arguments.

The total output is 3, 2, 1, Blastoff! — and then all four calls return in turn, back up to main. Nothing new is happening in the language: a method call is still the detour from Lesson 4a, and it happens to be a detour into the same method.

7. Four calls, one method

Picture it

The frames are the ones you drew in Chapter 4. What is new is that they all belong to the same method, each with a different value of n.

Every time a method gets called, Java creates a new frame containing its parameters and variables. Four calls, four frames, four separate copies of n — which is exactly Lesson 4a's rule that local variables live in their own frame.

8. Following the calls down and back

Worked example

The execution reads as a nested story: each call starts, produces output, hands over, and later gets control back.

countdown(3);

9. What does countdown(2) print?

Prediction

Follow the calls down.

public static void countdown(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        System.out.println(n);
        countdown(n - 1);
    }
}

10. Recursion generalises what threeLine could not

Concept

Section 4.1's newLine and threeLine worked, but they would not help if you wanted two newlines, or a hundred. A recursive method takes the count as a parameter.

public static void nLines(int n) {
    if (n > 0) {
        System.out.println();
        nLines(n - 1);
    }
}

The structure is the same as countdown. As long as n is greater than 0 it displays a newline and then invokes itself to display n-1 more. The total is 1 + (n - 1), which is exactly n — and writing the count that way is a good habit for convincing yourself a recursive method is right.

11. A base case that is never reached

Trap

public static void countdown(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        System.out.println(n);
        countdown(n);          // n, not n - 1
    }
}

public static void countdown(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        System.out.println(n);
        countdown(n - 1);
    }
}

12. Base case or recursive case?

Definition probe

Every recursive method has both, and they do different jobs.

13. Complete a recursive method

Fill the middle

Print n newlines.

14. Why is nothing new happening in the language?

Socratic

Recursion feels like a new feature. Argue that it is not.

15. Recursive stack diagrams

Section

Section 8.2

16. One frame per call, all for the same method

Concept

In Section 4.5 we used a stack diagram to represent the state of a program during a method invocation. The same kind of diagram makes a recursive method much easier to interpret — because every time a method is called, Java creates a new frame containing its parameters and variables.

base case — The case of a recursive method that does not make a recursive call, so the stack stops growing.

By convention the frame for main is at the top and the stack of other frames grows down — so you can draw the diagram on paper without guessing how far it will grow. main's frame is empty because it has no variables we are using.

17. Reading a recursive stack diagram

Notation

Four things are worth naming in this picture, and the last one is the whole reason the method terminates.

That last point is the practical consequence. A loop uses one frame however many times it repeats; a recursive method uses one per repetition, and frames are a finite resource.

18. What happens without a base case

Worked example

If there is no base case, or if it is never reached, the stack would grow forever — at least in theory. In practice the size of the stack is limited.

public static void forever(String s) {
    System.out.println(s);
    forever(s);
}

19. How many frames for countdown(4)?

Prediction

Count the calls, including the base case.

countdown(4);

20. Recursion depth against loop repetitions

Concept

A loop and a recursion can repeat the same number of times and use very different amounts of memory. That difference is worth knowing before you choose between them.

The third row is the practical limit. A loop counting to ten million is slow; a recursion ten million deep crashes. That is not a reason to avoid recursion — it is a reason to prefer it where the depth is small or grows slowly, which is exactly what Chapter 13's merge sort does.

21. Assuming a StackOverflowError means an infinite loop

Trap

// cause 1: no base case, or never reached
public static void forever(String s) {
    forever(s);
}

// cause 2: a correct method, called with too large an argument
public static int sum(int n) {
    if (n == 0) return 0;
    return n + sum(n - 1);      // correct, but sum(1000000) overflows
}

// the two questions:
//  1. Is there a base case, and does every call move toward it?
//  2. How deep will the recursion go for this input?

22. Watch the stack grow and shrink

Invariant

Step through countdown(2) and watch the frames.

Three — one per countdown frame, holding 2, 1 and 0. They share a name and nothing else, which is the same rule as Lesson 4a's two hour variables, applied three times over.

23. What error does forever throw?

Prediction

No base case at all.

public static void forever(String s) {
    System.out.println(s);
    forever(s);
}

24. Can a loop overflow the stack?

Counterexample

Compare the two mechanisms directly.

25. Value-returning recursive methods

Section

Section 8.3

26. A recursive definition becomes a recursive method

Concept

A recursive definition refers to the thing being defined. Many mathematical functions are defined this way because it is the simplest way — and if you can formulate a recursive definition, you can easily write a Java method to evaluate it.

// the mathematical definition:
//     0! = 1
//     n! = n * (n - 1)!

// the Java method:
public static int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

Do not confuse the mathematical symbol !, which means factorial, with the Java operator !, which means not. And note how closely the method matches the definition — line for line, which is the point of the whole section.

27. Building it up, one decision at a time

Notation

Lesson 4b's incremental development applies exactly here, and the order of the three steps is what makes recursion writable.

Notice that the hard-looking part is the shortest. Once the base case and the return type are settled, the recursive case is one line that says what the definition already said.

28. Tracing factorial(3)

Worked example

The flow of execution is like countdown, with one addition: values come back. Follow it down and then watch the multiplications happen on the way up.

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    int recurse = factorial(n - 1);
    int result = n * recurse;
    return result;
}

29. What does factorial(4) return?

Prediction

Multiply on the way back up.

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

30. Where the work actually happens

Concept

In countdown all the output happened on the way down. In factorial all the multiplication happens on the way up. That distinction is the key to reading any recursive method.

Many algorithms can be written concisely with recursive methods that perform computations on the way down, on the way up, or both. Asking which one a method does is the fastest way to understand it — and Lesson 8b's countup is the same method with the work moved from one to the other.

31. A base case that returns the wrong thing

Trap

public static int factorial(int n) {
    if (n == 0) {
        return 0;              // should be 1
    }
    return n * factorial(n - 1);
}

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

32. Order the events of factorial(2)

Ranking

Down, then up.

33. Write factorial from its definition

Fill the middle

0! = 1, and n! = n times (n-1)!

34. What is missing from this recursive definition?

Missing information

A definition that refers to itself is not automatically useful.

35. The leap of faith

Section

Section 8.4

36. Assume the recursive call works

Concept

Following the flow of execution is one way to read programs, but it quickly becomes overwhelming. Another way to understand recursion is the leap of faith: when you come to a method invocation, instead of following the flow, you assume that the method works correctly and returns the appropriate value.

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
    //          ^^^^^^^^^^^^^^^^
    //          assume this gives (n-1)! and ask:
    //          can I now compute n!?   Yes - multiply by n.
}

You are already practising this leap of faith whenever you use a library method. When you invoke Math.cos or System.out.println, you do not think about the implementation — you assume it works.

37. Two ways to convince yourself

Picture it

Both are legitimate. One of them stops scaling almost immediately.

The left column is fine for n = 3 and impossible for n = 30. The right column is the same length for every n — which is why it is the technique you actually use once the method gets interesting.

38. Fibonacci, where tracing is hopeless

Worked example

Here the leap of faith is not merely convenient. If you try to follow the flow of execution, even for small values of n, your head will explode.

public static int fibonacci(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

It is strange to assume the method works correctly when you have not finished writing it. But that is why it is called a leap of faith.

39. What is fibonacci(5)?

Prediction

Take the leap rather than tracing.

public static int fibonacci(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

40. Why Fibonacci's call tree branches

Concept

factorial makes one recursive call and fibonacci makes two. That single difference changes the shape of the computation completely.

One recursive call makes a chain; two make a tree. The tree does far more work — and repeats itself, since fib(2) is computed twice even here. That is a real inefficiency, and the standard fix (remembering results) is a topic for later. For now the point is that the leap of faith proves the method correct, and says nothing about whether it is fast.

41. Taking the leap before checking the base case

Trap

public static int countDigits(int n) {
    return 1 + countDigits(n / 10);
}
// "Assume countDigits(n/10) is correct, then adding 1 is right."
// Perfectly good reasoning - and it runs forever.

public static int countDigits(int n) {
    if (n < 10) {              // 1. a base case that resolves directly
        return 1;
    }
    return 1 + countDigits(n / 10);   // 2. moves toward it  3. combines correctly
}

42. Which check does each question belong to?

Definition probe

Three separate things must be true for a recursive method to be correct.

43. State the leap of faith as a question

Explain it to yourself

One sentence you can apply to any recursive method.

44. Does the leap of faith prove the method is fast?

Edge cases

It proved fibonacci correct. Ask what it did not prove.

45. Recursion against iteration

Section

Sections 8.1-8.4, in review

46. Two ways to repeat

Concept

Every recursive method in this lesson could be written with a loop, and every loop could be written recursively. Neither is more powerful; they differ in what they make easy to say.

// iterative
public static int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

// recursive
public static int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

The last row is the argument for recursion, and the second is the argument against it. Which matters more depends entirely on the problem.

47. Where the accumulated answer lives

Picture it

Both versions build up the same product. The difference is where the partial results are kept.

The recursive version's stack is the accumulator — the partial results are held in the waiting frames rather than in one variable. That is why depth is proportional to n, and it is the clearest way to see what the stack is actually for.

48. Choosing between them

Worked example

Three problems, three different answers. The deciding question is whether the problem's own definition is recursive.

// 1. sum an array          -> iterative. There is nothing recursive
//                              about "add up these elements".

// 2. factorial              -> either. The definition is recursive,
//                              but the loop is just as clear.

// 3. walk a folder tree     -> recursive. A folder contains folders,
//                              so the problem is recursive by nature.

49. Loop or recursion

Trade off

Fill the blanks from what each form costs and buys.

Neither column is better. The bottom row is the one that should decide it, and the top row is the one that occasionally overrules everything else.

50. The three questions, one last time

Concept

Whether a repetition is written as a loop or a recursion, the same three things must be true. Only the vocabulary changes.

Reading the table across is the point: these are the same three questions. A student who can check a loop can check a recursion, once they know which part plays which role.

51. Converting a loop to recursion by reflex

Trap

// summing an array recursively, for no reason
public static int sum(int[] a, int i) {
    if (i >= a.length) {
        return 0;
    }
    return a[i] + sum(a, i + 1);
}
// sum(millionElementArray, 0)  ->  StackOverflowError

// flat sequence -> loop
int total = 0;
for (int x : a) {
    total += x;
}

// nested structure -> recursion
// (a folder containing folders; a list split into halves)

52. Which form fits the problem?

Discrimination

Ask whether the problem contains smaller copies of itself.

53. How deep does the recursion go?

Prediction

Depth decides whether a correct method is usable.

public static int sum(int[] a, int i) {
    if (i >= a.length) return 0;
    return a[i] + sum(a, i + 1);
}

54. Explain recursion without saying 'it calls itself'

Explain it

The usual phrase describes the mechanism and not the idea.

55. countdown, factorial and fibonacci

Comparison

Three recursive methods, differing in what they return and how many calls they make. Fill the blanks.

The bottom row is what makes fibonacci expensive: one recursive call gives a chain of n frames, while two give a tree that can have exponentially many nodes.

56. The pattern to carry away

Pattern

Every recursive method has the same three parts, and checking them in this order is what makes recursion writable rather than mysterious.

public static ReturnType solve(Problem p) {

    if (isSmallEnough(p)) {          // 1. BASE CASE
        return directAnswer;         //    no recursive call here
    }

    ReturnType partial = solve(smaller(p));   // 2. PROGRESS
                                              //    strictly closer to the base

    return combine(p, partial);      // 3. COMBINE
                                     //    assume partial is correct
}

• Write the base case first — it is the part with no faith in it.
• Every call must move toward the base case, or the stack grows forever.
• The leap of faith: assume the recursive call is correct, and check only your step.
• Depth is proportional to the recursion, so ask how deep before you rely on it.

57. Check: the base case

Check

Work it out before you click.

public static int f(int n) {
    if (n == 0) {
        return 2;
    }
    return n * f(n - 1);
}

58. Check: stack depth

Check

Work it out before you click.

public static void countdown(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        System.out.println(n);
        countdown(n - 1);
    }
}

59. Check: the leap of faith

Check

Work it out before you click.

60. Where recursion is the only sensible shape

Real world

Factorial can be a loop. Some problems resist that, and they share a property worth being able to recognise.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, drawing as you go.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Four sections that add a second way to repeat — and, more usefully, a way of thinking about problems that contain smaller versions of themselves.

• A recursive method invokes itself with a different argument; nothing new happens in the language.
• Each call gets its own frame, so several copies of the same parameter exist at once.
• The base case makes no recursive call, which is what stops the stack growing.
• No base case, or one never reached, gives a StackOverflowError.
• A recursive definition translates directly into a method — factorial's two lines are its two clauses.
• Work can happen on the way down or on the way up; countdown prints before recursing, factorial multiplies after.
• The leap of faith: assume the recursive call is correct, and check only the combination step.
• Correctness and cost are separate questions — fibonacci is provably right and exponentially slow.