More general kinds of recursion

[comp1110-7L]
  • Fabian Muehlboeck

The recursive functions we have seen so far directly matched the structure of a data type definition. Sometimes, such a structure is less obvious, and sometimes, we don't follow the structure of a data type that closely. But as long as you can argue that a recursive call is on "smaller" input (in the sense that we get close to a base case), recursion is a good option.

Example 1. Factorial

[comp1110-24]
  • Liam O'Connor

You may have seen this self-referential (recursive) definition of factorial before:

\[\begin {array}{lcl} 0! &=& 1 \\ n! &=& (n-1)! \cdot n \end {array}\] int factorial(int n) { if (n == 0) { //the base case return 1; } else { // the recursive case (inductive case) return factorial(n-1) * n; } }

Try it out in the Java visualiser.

Warning 2. Factorial of Zero

[comp1110-7M]
  • Fabian Muehlboeck

In the lecture, we used the following definition of factorial:

/** * @param n a natural number (>= 0) */ int factorial(int n) { if(n==0) { return 0; } else if(n==1) { return 1; } else { return n * factorial(n-1); } }

This is not the standard definition of factorial, which usually holds that 0! == 1. Our definition above still matches the definition of factorial for every other valid input. The main point here is that a function may have multiple base cases, some of which may never be hit coming from a recursive case.

Definition 3. Divide and Conquer

[comp1110-26]
  • Liam O'Connor

Divide and conquer is a recursive problem solving strategy that solves a problem by following three distinct steps: Divide the problem into one or more subproblems that are smaller instances of the same problem; Conquer the subproblems by solving them recursively or directly if they are small enough; and Combine the subsolutions into the solution for the original problem. This approach is defined by reducing the problem size by a significant factor, such as halving the input in binary search, rather than just a constant amount (like in Factorial).

Example 4. Recursive binary search

[comp1110-27]
  • Liam O'Connor, Fabian Muehlboeck

A recursive version of our iterative Binary Search. Note that we had to add additional parameters lower and upper to give us enough flexibility to use this function recursively. Such generalisation is often required when working with recursive functions. Where needed, you can define another function without those parameters that simply calls the main one with suitable initial values.

/** Searches for a needle in a sorted haystack @param haystack a sorted (in ascending order) array of integers @param needle an integer to be searched for @param lower an integer expressing the lower bound of where needle could be in haystack; PRE: if exists i, haystack[i] == needle, then i >= lower @param upper an integer expressing the upper bound of where needle could be in haystack; PRE: if exists i, haystack[i] == needle, then i <= upper @return true iff there exists i, haystack[i] == needle */ boolean binarySearch(int[] haystack, int needle, int lower, int upper) { if(lower>upper) { return false; } int middle = (lower + upper) / 2; if(haystack[middle] == needle) { return true; } if(needle > haystack[middle]) { return binarySearch(haystack, needle, middle + 1, upper); } else { return binarySearch(haystack, needle, lower, middle - 1); } }

Try it out in the Java visualiser.

5. Recursion and Loop Invariants

[comp1110-7N]
  • Fabian Muehlboeck

Consider the iterative version of binary search, and specifically its loop invariant:

Example. Binary Search

[comp1110-1J]
  • Liam O'Connor

If we add a precondition to the spec of contains, that the input array is sorted, we can use a trick similar to our solution algorithm for our guessing game, which as we saw, can reduce the amount of iterations of the program from linear in the size of the input to logarithmic.

The idea is that we consistently pick the middle index from the range of possible indices. If the value at this index is our target, we have found what we're looking for, and we're done. If the value at this index is larger than our target, that means our desired index is to the left, and reduces the range of possible indices by half. If it is smaller, then our desired index is to the other half, on the right of the selected midpoint.

This narrows the range of possible indices, which permits us to repeat this technique until we reach single elements.

/** Searches for a needle in a sorted haystack @param haystack a sorted (in ascending order) array of integers @param needle an integer to be searched for @return true iff there exists i, haystack[i] == needle */ boolean binarySearch(int[] haystack, int needle) { int lower = 0; int upper = haystack.length - 1; while(lower <= upper) { // INV: if there exists i, haystack[i] == needle, // then lower <= i <= upper int middle = (lower + upper) / 2; if(needle == haystack[middle]) { return true; } else if(needle > haystack[middle]) { lower = middle + 1; } else { upper = middle - 1; } } return false; }

Contrast this with Recursive binary search. Notice how the loop invariant is essentially encoded in the preconditions for lower and upper. The line of reasoning is the same - the loop invariant must be true at the end of each loop, just as the preconditions of the recursive function call have to be true at each such recursive function call. The precondition must be true at the first call of the recursive function, just as the loop invariant has to be true when entering the loop.

In exchange, we can assume that the loop invariant is true at the start of the loop and after it, just as we can assume the precondition holds at the start of the function, and (typically) in the base cases.

Example 6. Merge Sort

[comp1110-29]
  • Liam O'Connor, Fabian Muehlboeck

Merge sort is both an efficient sorting algorithm (although it is not in-place) and a classic example of Divide and Conquer techniques. The algorithm works by dividing the input array in half, recursively sorting each half, and then merging the results. We can write an efficient merge function that combines two sorted lists into a single combined sorted lists. Note that we just loop through both arrays once, so this merge function is more efficient than simply appending the two arrays and then sorting them by other means.

/** * Returns the sorted combination of two * sorted arrays * @param left a sorted array of numbers * @param right a sorted array of numbers * @return a sorted array that contains * exactly the elements of left and right */ int[] merge(int[] left, int[] right) { int leftPos = 0; int rightPos = 0; int[] result = new int[left.length + right.length]; while(leftPos < left.length && rightPos < right.length) { int leftElement = left[leftPos]; int rightElement = right[rightPos]; if(leftElement < rightElement) { result[leftPos + rightPos] = leftElement; leftPos = leftPos + 1; } else { result[leftPos + rightPos] = rightElement; rightPos = rightPos + 1; } } while(leftPos < left.length) { result[leftPos + rightPos] = left[leftPos]; leftPos = leftPos + 1; } while(rightPos < right.length) { result[leftPos + rightPos] = right[rightPos]; rightPos = rightPos + 1; } return result; }

This function consistutes the "combine" step in the divide and conquer strategy. Now all that is left is the "dividing" and "conquering":

/** * Returns a sorted version of the part of the * given array between lower and upper * @param arr an array of integers, PRE: not null * @param lower the lower index of the part of the * array we want to sort, PRE: lower <= upper, * PRE: 0 <= lower < arr.length * @param upper the upper index of the part of the * array we want to sort, PRE: lower <= upper, * PRE: 0 <= upper < arr.length * @return a sorted version of the numbers in the * arr between lower and uppper */ int[] mergeSort(int[] arr, int lower, int upper) { if(arr.length==0) { return arr; } if(upper == lower) { return new int[]{arr[lower]}; } int middle = (lower + upper) / 2; int[] left = mergeSort(arr, lower, middle); int[] right = mergeSort(arr, middle+1, upper); return merge(left, right); }

Note: This functions efficiency can be slightly improved by only allocating one output array and passing it into each function, however this obscures the functionality of the algorithm.

Context

    Lecture. Recursion, Part II

    [comp1110-2026s2-lec05a]
    • August 25, 2026
    • Fabian Muehlboeck

    More general kinds of recursion

    [comp1110-7L]
    • Fabian Muehlboeck

    The recursive functions we have seen so far directly matched the structure of a data type definition. Sometimes, such a structure is less obvious, and sometimes, we don't follow the structure of a data type that closely. But as long as you can argue that a recursive call is on "smaller" input (in the sense that we get close to a base case), recursion is a good option.

    Example. Factorial

    [comp1110-24]
    • Liam O'Connor

    You may have seen this self-referential (recursive) definition of factorial before:

    \[\begin {array}{lcl} 0! &=& 1 \\ n! &=& (n-1)! \cdot n \end {array}\] int factorial(int n) { if (n == 0) { //the base case return 1; } else { // the recursive case (inductive case) return factorial(n-1) * n; } }

    Try it out in the Java visualiser.

    Warning. Factorial of Zero

    [comp1110-7M]
    • Fabian Muehlboeck

    In the lecture, we used the following definition of factorial:

    /** * @param n a natural number (>= 0) */ int factorial(int n) { if(n==0) { return 0; } else if(n==1) { return 1; } else { return n * factorial(n-1); } }

    This is not the standard definition of factorial, which usually holds that 0! == 1. Our definition above still matches the definition of factorial for every other valid input. The main point here is that a function may have multiple base cases, some of which may never be hit coming from a recursive case.

    Definition. Divide and Conquer

    [comp1110-26]
    • Liam O'Connor

    Divide and conquer is a recursive problem solving strategy that solves a problem by following three distinct steps: Divide the problem into one or more subproblems that are smaller instances of the same problem; Conquer the subproblems by solving them recursively or directly if they are small enough; and Combine the subsolutions into the solution for the original problem. This approach is defined by reducing the problem size by a significant factor, such as halving the input in binary search, rather than just a constant amount (like in Factorial).

    Example. Recursive binary search

    [comp1110-27]
    • Liam O'Connor, Fabian Muehlboeck

    A recursive version of our iterative Binary Search. Note that we had to add additional parameters lower and upper to give us enough flexibility to use this function recursively. Such generalisation is often required when working with recursive functions. Where needed, you can define another function without those parameters that simply calls the main one with suitable initial values.

    /** Searches for a needle in a sorted haystack @param haystack a sorted (in ascending order) array of integers @param needle an integer to be searched for @param lower an integer expressing the lower bound of where needle could be in haystack; PRE: if exists i, haystack[i] == needle, then i >= lower @param upper an integer expressing the upper bound of where needle could be in haystack; PRE: if exists i, haystack[i] == needle, then i <= upper @return true iff there exists i, haystack[i] == needle */ boolean binarySearch(int[] haystack, int needle, int lower, int upper) { if(lower>upper) { return false; } int middle = (lower + upper) / 2; if(haystack[middle] == needle) { return true; } if(needle > haystack[middle]) { return binarySearch(haystack, needle, middle + 1, upper); } else { return binarySearch(haystack, needle, lower, middle - 1); } }

    Try it out in the Java visualiser.

    Recursion and Loop Invariants

    [comp1110-7N]
    • Fabian Muehlboeck

    Consider the iterative version of binary search, and specifically its loop invariant:

    Example. Binary Search

    [comp1110-1J]
    • Liam O'Connor

    If we add a precondition to the spec of contains, that the input array is sorted, we can use a trick similar to our solution algorithm for our guessing game, which as we saw, can reduce the amount of iterations of the program from linear in the size of the input to logarithmic.

    The idea is that we consistently pick the middle index from the range of possible indices. If the value at this index is our target, we have found what we're looking for, and we're done. If the value at this index is larger than our target, that means our desired index is to the left, and reduces the range of possible indices by half. If it is smaller, then our desired index is to the other half, on the right of the selected midpoint.

    This narrows the range of possible indices, which permits us to repeat this technique until we reach single elements.

    /** Searches for a needle in a sorted haystack @param haystack a sorted (in ascending order) array of integers @param needle an integer to be searched for @return true iff there exists i, haystack[i] == needle */ boolean binarySearch(int[] haystack, int needle) { int lower = 0; int upper = haystack.length - 1; while(lower <= upper) { // INV: if there exists i, haystack[i] == needle, // then lower <= i <= upper int middle = (lower + upper) / 2; if(needle == haystack[middle]) { return true; } else if(needle > haystack[middle]) { lower = middle + 1; } else { upper = middle - 1; } } return false; }

    Contrast this with Recursive binary search. Notice how the loop invariant is essentially encoded in the preconditions for lower and upper. The line of reasoning is the same - the loop invariant must be true at the end of each loop, just as the preconditions of the recursive function call have to be true at each such recursive function call. The precondition must be true at the first call of the recursive function, just as the loop invariant has to be true when entering the loop.

    In exchange, we can assume that the loop invariant is true at the start of the loop and after it, just as we can assume the precondition holds at the start of the function, and (typically) in the base cases.

    Example. Merge Sort

    [comp1110-29]
    • Liam O'Connor, Fabian Muehlboeck

    Merge sort is both an efficient sorting algorithm (although it is not in-place) and a classic example of Divide and Conquer techniques. The algorithm works by dividing the input array in half, recursively sorting each half, and then merging the results. We can write an efficient merge function that combines two sorted lists into a single combined sorted lists. Note that we just loop through both arrays once, so this merge function is more efficient than simply appending the two arrays and then sorting them by other means.

    /** * Returns the sorted combination of two * sorted arrays * @param left a sorted array of numbers * @param right a sorted array of numbers * @return a sorted array that contains * exactly the elements of left and right */ int[] merge(int[] left, int[] right) { int leftPos = 0; int rightPos = 0; int[] result = new int[left.length + right.length]; while(leftPos < left.length && rightPos < right.length) { int leftElement = left[leftPos]; int rightElement = right[rightPos]; if(leftElement < rightElement) { result[leftPos + rightPos] = leftElement; leftPos = leftPos + 1; } else { result[leftPos + rightPos] = rightElement; rightPos = rightPos + 1; } } while(leftPos < left.length) { result[leftPos + rightPos] = left[leftPos]; leftPos = leftPos + 1; } while(rightPos < right.length) { result[leftPos + rightPos] = right[rightPos]; rightPos = rightPos + 1; } return result; }

    This function consistutes the "combine" step in the divide and conquer strategy. Now all that is left is the "dividing" and "conquering":

    /** * Returns a sorted version of the part of the * given array between lower and upper * @param arr an array of integers, PRE: not null * @param lower the lower index of the part of the * array we want to sort, PRE: lower <= upper, * PRE: 0 <= lower < arr.length * @param upper the upper index of the part of the * array we want to sort, PRE: lower <= upper, * PRE: 0 <= upper < arr.length * @return a sorted version of the numbers in the * arr between lower and uppper */ int[] mergeSort(int[] arr, int lower, int upper) { if(arr.length==0) { return arr; } if(upper == lower) { return new int[]{arr[lower]}; } int middle = (lower + upper) / 2; int[] left = mergeSort(arr, lower, middle); int[] right = mergeSort(arr, middle+1, upper); return merge(left, right); }

    Note: This functions efficiency can be slightly improved by only allocating one output array and passing it into each function, however this obscures the functionality of the algorithm.

    Related

      Recursion

      [comp1110-2Z]
      • Liam O'Connor, Fabian Muehlboeck

      Definition. Recursive Type

      [comp1110-7F]
      • Fabian Muehlboeck

      A recursive type is a type whose instances may "contain" other ("smaller") instances of the same type. It is typically described in terms of:

      • At least one base case
      • At least one recursive case (also called "inductive case")

      Base cases describe those instances that do not contain further instances of the same type.

      Recursive cases describe those instances that do contain further instances of the same type.

      With this, we can build very large and potentially complex data structures.

      Definition. Linked Lists

      [comp1110-2S]
      • Liam O'Connor, Fabian Muehlboeck

      A linked list is a way to store a sequence of items, one after another, where each item points to the next. Unlike arrays, it is not necessary to know ahead of time how many items the list will contain. It is a very common example of a recursive data type, where a type occurs as a field of itself. Here, we describe a linked list of integers by defining a recursive class type:

      // An IntList is either // null - representing the empty list // an IntList object, representing a part of a non-empty list class IntList { int value; IntList rest; IntList(int v, IntList r) { value = v; rest = r; } }

      Here value is the first integer in the list, rest is the rest of the list (or null if there are no more integers). Therefore, null plays the role of the base case of our recursion, while an IntList object (which contains another IntList) is the recursive case.

      // Start with an empty list IntList list = null; // Add 3 first list = new IntList(3, list); // Add 2 in front of 3 list = new IntList(2, list); // Add 1 in front of 2 list = new IntList(1, list);

      Definition. Recursive Function

      [comp1110-7G]
      • Fabian Muehlboeck, Liam O'Connor

      A recursive Function is a function that is defined in terms of itself. The idea here is that you can solve a problem by first solving a smaller part of it, and then adjusting that solution to become a solution for the whole problem. Like a recursive data type, it's code typically hase:

      • At least one base case
      • At least one recursive case (also called "inductive case")

      Base cases describe those cases where a problem cannot be decomposed into smaller parts anymore - at this point, it should be easy to produce a solution for this relatively small problem.

      Recursive cases describe those cases where you can first solve some smaller problems (by calling the same function, but with different input), and then combine those solutions into a solution for the current problem.

      Recursive functions and recursive data types are a natural match, because the structure of the data can mirror the structure of your code: your function will have a base case for each base case of your recursive data type, and a recursive case for each recursive case of your recursive data type.

      Example. Summing up a List of Integers

      [comp1110-2U]
      • Liam O'Connor, Fabian Muehlboeck

      Recursive data types like linked lists are usually best handled by recursive functions:

      int sum(IntList l) { if(l == null) { return 0; // base case } else { return l.value + sum(l.rest); //recursive case } }

      However, in this case, because the last step performed in all recursive cases is to invoke the function recursively, We can translate the above program into a loop:

      int sumLoop(IntList l) { int sum = 0; // running total of list while(l != null) { // INV: sum is sum of values of all list nodes from original l to current l (exclusive) sum = sum + l.value; l = l.rest; } return sum; }

      This works by starting at the first list cell, adding its value to the running total, then moving to the next cell by adjusting l to be l.next, and repeating until we reach null.

      Stack Frames and Recursion

      [comp1110-25]
      • Liam O'Connor, Fabian Muehlboeck

      Compare Example [comp1110-2U] to this program that gives the same results:

      int sum(IntList l) { if(l == null) { return 0; // base case } else { int num = l.value; int rsum = sum(l.rest); return num + rsum; //recursive case } }

      All this program does is to give intermediate names to the results of looking at the value of an IntList node and of doing the recursive call. This makes it much nicer to look at what is happening in the Java Visualizer (link to code above). It also shows an important point about local variables. Each time you call the sum function, the Java Visualizer shows you a new frame on top of the previous one. These frames are part of the so-called call stack.

      Local variables (the ones in the parameters of the function and the ones you define within the code) are local to each invocation of the recursive function, represented by a (call) stack frame. Each frame corresponds to a particular function call that has not yet finished, and contains the local variables of that particular invocation. This means that if you have n nested calls to sum, you will have n stack frames for sum on the call stack, on top of the frames from where sum was called originally (in our case, say, the main function). Within those, there will be n different versions of l, each pointing to successive nodes in the linked list, plus at least n-1 versions of num, each containing potentially different integer values.

      If you change the value of a local variable within a function, you will only affect the value of that variable within the current function invocation's frame. All other frames will be unaffected, and when you call a function, the values of your local frame will be preserved until the function returns - the arguments get copied into the new frame.

      The caveat here is when arguments are passed by reference, where the reference is copied to the new stack frame, but the value it points to is shared between caller and callee.

      Definition. Stack Trace

      [comp1110-7O]
      • Fabian Muehlboeck

      When your Java program crashes, it will typically print information about the exception that made it crash, along with a stack trace:

      Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "<local1>" is null at Program.helper(Program.java:9) at Program.main(Program.java:14)

      Here, the stack trace consits of the lines starting with the word "at". For every frame of your call stack, this will contain a line, in the same order as the call stack. That means that the top line is the place where the exception occurred. All the other lines indicate where the function whose frame is above that line was called.

      This information can be very helpful when debugging your program, because it both tells you where the problem happened, and a lot of information about how you got there.

      Warning. Stack Overflow

      [comp1110-7P]
      • Fabian Muehlboeck

      When using Recursion, your program might crash with a very long Stack Trace, and the specific exception is java.lang.StackOverflowError:

      Exception in thread "main" java.lang.StackOverflowError at Program.overflow(Program.java:3) at Program.overflow(Program.java:3) at Program.overflow(Program.java:3) at Program.overflow(Program.java:3) at Program.overflow(Program.java:3) at Program.overflow(Program.java:3) [... many more identical lines ...]

      Essentially, your computer has some limited amount of space in its memory to store your stack frames, and when you have run out, a stack overflow happens, usually crashing your program.

      This is usually because you got something wrong in writing your recursive code, and so your program loops forever, but with recursion, it eventually runs out of space. Make sure that your inputs to your recursive call are different (and "smaller") from the arguments to the current function!

      Another possible reason is that you did write the recursive code correctly, but are operating on a data structure that is too large. This can happen, though you will usually not encounter such cases early in a computing degree. There are ways to increase the size reserved for stack frames, though it is not necessarily guaranteed that that will be a good solution. When working with large data, you might have to switch to iteration. However, don't see this as a reason to never use recursion - premature optimisation is never a good idea!

      Definition. Tree

      [comp1110-7H]
      • Fabian Muehlboeck

      A tree is a recursive data type that consists of nodes, each of which may have some number of "child nodes", or children, which are themselves nodes of the tree. Each node has at most one parent, and the tree contains one node that has no parents, called the root of the tree. Nodes that have no children are also called leaves.

      Each node can be treated as the root of a subtree starting with that node, ignoring its parent and any further ancestors.

      When drawing a tree, we usually put the root on top, and the tree grows downwards. The following is a picture of a tree with a root node with two children. The first child only has one other child, while the second one has two more.

      As the saying goes, this happened because computer scientists rarely go outside.

      Trees are one of the most fundamental data structures in computer science. You will encounter them everywhere.

      There is a large variety of potential tree data structures. Some have very rigid structures, where every node must either be a leaf or have the same number of children. Others allow nodes to have any number of children between some minimum or maximum. Some trees draw strict distinctions between leaves and inner nodes - oftentimes the distinction is that only one of them carries data. Some trees are formed by children knowing (pointing at) their parents, some trees are formed by parents knowing (point at) their children, in some trees, you can go in either direction.

      Example. Linked Lists are Trees

      [comp1110-7I]
      • Fabian Muehlboeck

      A Linked List as defined earlier is a tree where nodes carry data and have either 0 or 1 children, and only parents know their children.

      Example. Binary Trees

      [comp1110-7J]
      • Fabian Muehlboeck

      A Binary Tree is a tree where each node has 0 or 1 children on the "left", and 0 or 1 children on the "right" (for a total of between 0 and 2 children per node). Here is a suitable data definition:

      //BinaryTree // either null (base case) // a BinaryTree object ("node") (recursive case) class BinaryTree { BinaryTree(int n, BinaryTree l, BinaryTree r) { number = n; left = l; right = r; } int number; BinaryTree left; BinaryTree right; }

      We can now write a sum function to get the sum of all the numbers stored in the tree:

      int sum(BinaryTree tree) { if(tree == null) { // base case return 0; } else { // recursive case return tree.number + sum(tree.left) + sum(tree.right); } }

      Note that because the tree has two fields that recursively point at other tree instances, we need to have two recursive function calls.

      This example is where recursion gives you an advantage over iteration - in contrast to linked lists, it is much harder to write a while loop that does the same as the above recursive function. This is because the stack frame is now useful to store the intermediate result of calculating the sum of the values in the left child while we are calculating the sum of the values in the right child. If you try to write this with a loop, you will have to effectively manage a stack of such intermediate values yourself (there are some other tricks you will learn later in a computing degree that will sometimes let you avoid this, but nothing beats the recursion here in terms of its simplicity).

      Example. The File System forms a Tree

      [comp1110-7K]
      • Fabian Muehlboeck

      The file system mostly forms a tree where folders are nodes and files are leaves. Using the File class, you can get the children of a directory by calling listFiles, which returns an array of all files and directories contained within a directory:

      void printAll(File f, String prefix) { if(f.isFile()) { // base case IO.println(prefix + "/" + f.getName()); } else { File[] children = f.listFiles(); int i = 0; while(i < children.length) { printAll(children[i], prefix + "/" + f.getName()); // recursive case i = i + 1; } } }

      Here, prefix is what is called an accumulator - as you go deeper into the recursion, the prefix string becomes bigger and bigger, accumulating information along the way. Here, we use it to keep track of where we came from (essentially, it expresses the path from the root to the current node, as a string).

      The Java File Class also has a getParentFile method, which allows you to access the parent of a node. At the root of the file system, this returns null .

      bars magnifying-glass caret-down plus minus arrow-right xmark