A Diversion to Recursion

• Recursion is the practice of dividing a problem up into smaller problems of the same form.
  • The sub-problems must have the same form as the larger problem, or it isn’t recursion
• Since the sub-problems have the same form as the larger problem, they can be solved using the same function
  • From a code perspective, the defining characteristic of recursion is a function which calls itself internally
    • This can feel weird, but if you think about how we trace things, there isn’t anything wrong with it

Solving the same (simpler) problem

• Say you needed to fundraise $1000 for an important cause
  • Tough to get a single $1000 donation
  • Could instead task 10 friends with raising $100
    • Each friend could task 10 other friends with raising $10
    • Then those friends could find 10 people who would each donate a dollar
• Solving the problem the same way each time:
  • Dividing up the problem and asking those people to solve a simpler (cheaper) problem
  • It must end somewhere, generally called the base case
    • Here that would have been at the $1 donation point

Recursive Factorial

• The factorial function can be defined in two different ways, one of which lends itself nicely to recursion \[n! = (n-1) \times (n-2) \times (n-3) \times \cdots \times 1\] or \[n! = \begin{cases} 1 & \text{if $n$ is 0} \\ n \times (n-1)! & \text{otherwise}\end{cases}\]

• The second can be expression computationally as:

  def factorial(n):
      if n == 0:    # Our base case
          return 1
      else:     # Our recursive case
          return n * factorial(n - 1)

The Recursive Paradigm

• Most recursive functions you encounter will have bodies that fit in the following general pattern:

  if |||test for simple case|||:
      |||Compute and return simple solution without recursion|||
  else:
      |||Divide the problem into one or more subproblems of the same form|||
      |||Call this same function recursively to solve those subproblems|||
      |||Return the solutions of the various subproblems|||

• Finding a recursive solution is thus commonly a matter of:

  • Identifying simple cases that you can solve without recursion
  • Finding a recursive decomposition that breaks each problem up into smaller, simpler subproblems of the same type

Example 1: Money Raising

• Suppose we wanted to mimic the situation we described earlier, where a function needs to raise money
• Let’s print out how much each person might end up contributing

Example 2: Sierpinski Carpet

The Merge Sort Plan

The plan with merge sort is thus to:

1. Divide the array into two halves: a1 and a2
2. Sort each of a1 and a2 recursively
3. Merge elements into the original array by choosing the smallest element from a1 or a2 on each cycle

We’ll follow this process all the way through on pen and paper now to see that it works!

Merge Sort Code Implementation

def merge_sort(array):
    if len(array) > 1: #base case check
        mid = len(array) // 2
        a1 = array[:mid]
        a2 = array[mid:]
        merge_sort(a1) #recursive calls
        merge_sort(a2)
        merge(array, a1, a2)

def merge(array, a1, a2):
    n1 = len(a1)
    n2 = len(a2)
    i1 = 0 #current front indices
    i2 = 0
    for i in range(len(array)):
        if (i1 < n1 and a1[i1] < a2[i2]) or i2 == n2:
            array[i] = a1[i1]
            i1 += 1
        else:
            array[i] = a2[i2]
            i2 += 1

Merge Sort Complexity

So how many levels?

• Same division-by-two situation we had with Binary Search!
  • Equal to the number of times you can divide the array in half until only a single element remaining
  • Number of steps \(k\) was given by: \[k = \log_2(N)\]
• Total complexity of merge sort is thus \[\mathcal{O}(N \log_2(N))\]

Comparing

• Based on this, the merge sort would be over 50,000x faster than selection sort for an array of 1 million values!

Standard Complexity Classes

• Most tend to fall into one of a small number of complexity classes

• In general, any problem whose complexity can not be expressed as a polynomial is considered intractable

P vs NP