Recursion on Trees

CMPT 225

Recursion

Recursion: A definition of a function is recursive if the body cointains an application of itself.

Consider: $S(n)=\sum_{i=0}^{n} i$

or

$S(n) = \begin{cases} 0 & \text{if } n=0\\ n+S(n-1) & \text{if } n>0 \end{cases}$

These two descriptions of $S(n)$ suggest two implementations:

e.g.:

S(n){
  s=0
  for i=1..n
    s=s+i
  return s
}

or

S(n){
  if n=0
    return 0
  else
    return n+S(n-1)
}

Recursive Version

• -> S(4)
  • -> S(3)
    • -> S(2)
      • -> S(1)
        • -> S(0)
        • returns 0
      • returns 1+0
    • returns 2+1=3
  • returns 3+3=6
• returns 4+6=10

Iterative version:

$S = 0 + \sum_{i=1}^{n} i = 1 + \sum_{i=2}^{n} i = 3 + \sum_{i=3}^{n} i = \dots\\ = 0+1+2+3+4$

The same computation, but a different control strategy.

Recursion & The Call Stack

Code:

S(n){
  if(n=0){
    r=0
  }else{
    r=n+S(n-1)
  }
  return r
}

Compute p=S(2):

• Call S(2):
  • n = 2
  • r = ? ->
    • Call S(1):
      • n=1
      • r=? ->
        • Call S(0):
          • N=0
          • r=0
          • return 0
      • return 1+S(0)
  • return 2+S(1)

The call stack at the end:

After the call the S(2) is complete, the entire call stack of S to S to S is gone.

There are 2 more slides containing slightly different versions of the same diagrams. They do not provide any extra information.

Recursion on Trees

• We will often use recursion & induction on trees.
  • e.g. the tree rooted a v has some property if its subtrees have some related property
• e.g. the height of node v in a binary tree may be defined by:

$h(v) = \begin{cases} 0 & \text{ if v is a leaf}\\ 1 + \text{max}\{h(\text{left}(v)), h(\text{right}(v))\} & \text{ otherwise} \end{cases}$

(We can define h(left(v)) to be -1 if left(v) does not exist, and sim. for right(v)).

Recurssion a Trees Examples

height of node v in T:

$h(v) = \begin{cases} 0 & \text{ if v is a leaf}\\ 1+ max\{h(\text{left}(v)),h(\text{right}(v))\} & \text{ ow} \end{cases}$

for the follwing tree: $h(v)=?$

• v
  • a
    • e
      • g
      • h
    • f
      • i
  • b
    • c
    • d

Recursion on Trees Example (pt 2)

(See math equation of previous slide)

h(v) = 3

• v (3)
  • a (2)
    • e (1)
      • g (0)
      • h (0)
    • f (1)
      • i (0)
  • b (1)
    • c (0)
    • d (0)

Pseudo-code version:

height(v){
  if v is a leaf
    return 0
  if v has one child u
    return 1+height(u)
  else
    return 1+max(height(left(v)), height(right(v)))
}

Traversals of Binary Tree

• A traversal of a graph is a process that “visits” each node in the graph once.
• We consider 4 standard tree traversalt:
  1. level order
  2. pre-order
  3. in-order
  4. post-order
• 2,3,4 begin at the root & recursively visit the nodes in each subtree & the root. They vary in the relative ???(can’t read).

(Level order later)

Code:

pre-order-T(v){
  visit v
  pre-order-T(left(v))
  pre-order-T(right(v))
}

pre-order-T(v) does nothing if v does not exist.

• v is visited before any of its decendants
• every node in the left subtree is visited before any node in the right subtree.

Tree to come back to:

• A
  • B
    • D
    • E
  • C
    • F

Pre-order-traversal: A,B,D,E,C,F

in-order-T

code:

in-order-T(v){
  in-order-T(left(v))
  visit v
  in-order-T(right(v))
}

In order traversal: D,B,E,A,C,F

post-order-T

code:

post-order-T(v){
  post-order-T(left(v))
  post-order-T(right(v))
  visit v
}

Post order traversal: D,E,B,F,C,A

End

…some repeated slides… unknown reason