Status

• Quizzes (fill-in-blanks, 01a: late policy question)
• Big-O answers on 02B slides
• Empty arrays contain...?
• Discussion 01 closed... to be summarized next time.
• Beware contrived examples (lectures and quizzes)
  • so you learn to read bad code, but write good code

JVM: Three parts of memory

• (runtime) stack: methods details
  • incl. parameters, local variables
  • primitives vs object references
• heap: objects (incl. instance variables)
• static/class memory*: static variables, (code)

(JVM = Java Virtual Machine)
*currently called "permanent generation" storage in JVM

Runtime Stack

• Composed of method activation records (aka: stack frames, activation frames)
• Starts with main
• One for each method call, current call on top
• See this in stack trace from runtime crash

Sidetrip: Back to the 02A slides we didn't get to for some examples of this

JVM Conclusion

• Runtime stack very helpful to understand both methods and recursion
• Return to heap and static memory later...

Concept: Recursion

• Conceptually: Compute a solution to a problem by first computing solutions to smaller instances of the same problem (using the same technique)
• Practically: A method that calls itself (usually directly)

Algorithm: Handing out papers (1/2)

An iterative (loop-based) approach (called on a Teacher object):

handOutPapers(pile):
  student = first student in line
  while pile is not empty:
    paper = pile.removeTop() 
    give paper to student
    student = next student in line    

• Assuming more papers than students here.
• This method does all the work.

Algorithm: Handing out papers (2/2)

A recursive approach (called on a Student object):

handOutPapers(pile):
  if pile is not empty:
    paper = pile.removeTop()
    keep paper
    next = next student in line
    next.handOutPapers(pile)

• So stack gets smaller each time (thanks to removeTop)
• But each student follows the exact same algorithm!
• Stops when a student gets empty stack (huh?)

Alternatives

More descriptive of real life:

handOutPapers(pile):
  paper = pile.removeTop()
  keep paper
  if pile is not empty:
    next = next student in line
    next.handOutPapers(pile)

But in code: what if passed an empty pile?

handOutPapers(pile):
  if pile is not empty:
    paper = pile.removeTop()
    keep paper
    if pile is still not empty:
      next = next student in line
      next.handOutPapers(pile)

Original version was simpler. Often simplest code if you continue to 0 or empty case.

Practical example: Quiz 02, last question

public class CodeD {
  public static void main(String[] args) {
    lotsAndLots(0);
  }

  public static void lotsAndLots(int num) {
    System.out.println(num);
    lotsAndLots(num + 1);
  }
}

• What happened? For me: printed up to 11620, then crashed with StackOverflowError
• Why? (in terms of runtime stack) Ran out of stack space due to infinite recursion

Example: Print digits n to 1

public static void printDigits(int n) {
  if (n == 0) {
    return;  //base case: do nothing
  }else {
    System.out.println(n);
    printDigits(n - 1);  //recursive call on smaller problem
  }
}

• What would printDigits(-1) do? "infinite" recursion
• What if we swap the order of the two lines in the else?

Example: Print digits 1 to n

public static void printDigits(int n) {
  if (n <= 0) {
    return;  //base case: do nothing
  }else {
    printDigits(n - 1);    //recursive call on smaller problem
    System.out.println(n); //print after returning from recursion
  }
}

• Else is actually optional here, but reflects logic
• if doesn't always have to be for base case

Example: Print digits 1 to n (alternatives)

public static void printDigits(int n) {
  if (n <= 0) {
    return;  //base case: do nothing
  }
  printDigits(n - 1);    //recursive call on smaller problem
  System.out.println(n); //print after returning from recursion
}

public static void printDigits(int n) {
  if (n > 0) {
    printDigits(n - 1);    //recursive call on smaller problem
    System.out.println(n); //print after returning from recursion
  }
  //implied base case: do nothing if n <= 0.
}

Example: Digits n to 1 as String

What if we want to generate a String of the numbers?

public static void main(String[] args) {
  String str = allDigits(4);
  System.out.println(str);
}

public static String allDigits(int n) {
  if (n <= 0) {
    return "";
  }else {
    return n + " " + allDigits(n - 1);
  }
}

• What does it print?
• How do we reverse the digit order?

Recursion Lessons

• Recursion == method calls itself
• Needs to break the problem into smaller pieces each time
• Each call creates another "copy"/version of the method on the runtime stack
  • but remembers where it is in current method
• Need 1 (or more) base cases (stopping conditions)
• Stack of recursive calls then returns, one at a time
• Can also do some work after ("on the way back") from the recursive calls

Classic Example: Factorial

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

Big-O?

Classic Example: Fibonacci

/** Computes nth Fibonacci number: 1,1,2,3,5,8,13,... */
public static int fibonacci(int n) {
  if (n <= 0) {
    return 0;  //error: n should not be less than 1
  }else if (n <= 2) {
    return 1;
  }else {
    return fibonacci(n - 1) + fibonacci(n - 2);
  }
}

Big-O?

Classic Example: Fibonacci, more efficiently

public static int fibonacci(int n) {
  return fib(0, 1, n);
}

private static int fib(int prev, int curr, int n) {
  if (n <= 1) {
    return curr;
  }else {
    return fib(curr, prev + curr, n - 1);
  }
}

• Public method and private helper method
• Big-O now?

For next time...

• So far: recursion as alternative to loops
• Quiz 03, due before next class, will give you more XP w/ recursion
• A04: write 5 methods both interactively and recursively
• Next week: backtracking and using recursion on problems that loops can't (easily) handle