Brandon Rozek

Lecture for November 27

Recursion

When doing recursion, make sure not to use loops.

Recursion is when a function makes a function call to itself.

It consists of two parts:

You can have one or more base cases or caller cases.

To teach recursion, we’ll start with a problem that should be written iteratively (with loops) but we’ll show how to do it with recursion.

Example: Counting Down

void CountDown(int number) {
  while (number > 0) {
    System.out.println(number + " ");
    number = number - 1;
  }
  System.out.println("Blast Off")
}
  1. How does this loop stop? – Base Case
  2. How does this loop change each time through? – Smaller caller case

Base Case: It stops when the number equals 0

// Base Case
if (number == 0) {
  System.out.println("Blast Off");
  return;
}

Smaller Caller Case: It decreases number by 1

// Smaller Caller Case
System.out.print(number + " ");
countDownRecursive(number - 1);

Put it together…

void countDownRecursive(int number) {
  if (number == 0) {
    System.out.println("Blast Off");
  } else {
    System.out.print(number + " ");
    countDownRecursive(number - 1);
  }
}

Prints 10 9 8 7 6 5 4 3 2 1 Blast Off

Stack Snapshots

Every time you make a recursive call, it keeps track of all the local variables at the current function call and pushes it onto the stack.

That means if you make 10 recursive calls, you’ll have 10 slots added onto the stack. If you want to return back to the beginning, you would need to return 10 times.

Order Matters

Whether you do the recursive step first or some other action, it completely changes the output. Look at the following example that’s similar to countDownRecursive.

void countUpRecursive(int number) {
  if (number == 0) {
    System.out.println("Blast Off");
  } else {
    // Notice the swapping of the next two lines
    countUpRecursive(number - 1);
    System.out.print(number + " ");
  }
}

This would print out Blast Off 1 2 3 4 5 6 7 8 9 10

Example: Summing up to a number

This would be our iterative solution

int sum(int number) {
  int sum = 0;
  while (number > 0) {
    sum += number;
    number--;
  }
  return sum;
}

How does this loop stop?

​ Same as before. Think about it, if the number you pass in is zero, what should be the result of sum? Zero. Since adding up from 0 to 0 is just 0.

if (number == 0) {
  return 0;
}

How does this loop change each time through?

​ You want to update your sum, so return the sum of the next call to the current sum.

return (number + sum(number - 1));

Putting it all together

int sumRecursive(int number) {
  if (number == 0) {
    return 0;
  } else {
    return number + sumRecursive(number - 1);	
  }
}

How to do it iteratively.

void linearSearch(int[] array, int number) {
  int i = 0;
  while (i < array.length && number != array[i]) {
    i++;
  }
  if (i == array.length) {
    System.out.println("Not Found");
  } else {
    System.out.println("Found");
  }
}

Base Case: There are two base cases, when it reaches the end of the array and when it finds the number

if (array.length == i) {
  System.out.println("Not Found");
} else (array[i] == number) {
  System.out.println(number + " found at index " + i);
}

Smaller Caller Case: Check the next element

linearSearchRecursion(number, array, i + 1);

Putting it all together…

void linearSearchRecursion(int[] array, int number) {
  if (array.length == i) {
    System.out.println("Not Found");
  } else if (array[i] == number) {
    System.out.println(number + " found at index " + index);
  } else {
    linearSearchRecursion(number, array, i + 1);
  }
}

This is a much more efficient search than the linear search we have been doing. The only condition is that your array must be sorted beforehand.

A regular linear search O(n) – Check at most all of the elements of the array.

Binary Search O(log(n)) – Checks at most ceil(log(n)) elements of an array.

To demonstrate this with real numbers, let’s take an array of 100 elements

Crazy right?

Implementation

Iterative approach

void binarySearch(int number, int[] array) {
  int lower = 0;
  int upper = array.length - 1;
  int mid = (lower + upper) / 2
  while (lower <= upper && array[mid] != number) {
    mid = (lower + upper) / 2;
    if (array[mid] < number) {
      lower = mid + 1;
    } else if () {
      upper = mid -1;
    }
  }
  if (lower > upper) {
    System.out.println("Not Found");
  } else {
    System.out.println(number + " found at index " + mid);
  }
}

Recursive Approach

Base Case: There are two cases, you either found it, or you made it to the end of the array without finding it

if (lower > upper) {
  System.out.println("Not Found");
} else if (array[mid] == number) {
  System.out.println(number + " found at index " + mid);
}

Smaller Caller Case: Change the lower or upper bounds to cut the search in half

if (array[mid] < number) {
  lower = mid + 1;
  binarySearchRecursive(number, array, lower, upper);
} else if (array[mid] > number) {
  upper = mid - 1;
  binarySearchRecursive(number, array, lower, upper);
}

Putting it together….

binarySearch(int number, int[] array, int lower, int upper) {
  if (lower > upper) {
  	System.out.println("Not Found");
  } else if (array[mid] == number) {
  	System.out.println(number + " found at index " + mid);
  }
  else if (array[mid] < number) {
  	lower = mid + 1;
  	binarySearchRecursive(number, array, lower, upper);
  } else if (array[mid] > number) {
  	upper = mid - 1;
  	binarySearchRecursive(number, array, lower, upper);
  }
}