1. Data Structures & Algorithms
Recursion and Trees 1

2. Recursion Fundamental concept in math and CS Recursive definition
Defined in terms of itself
aN = a*aN-1, a0 = 1
Recursive function
Calls itself
int exp(int base, int pow) {
return (pow == 0 ? 1
: base*exp(base, pow-1)); } 2

3. Recursion Recursive definition (and function) must:
1. have a base case – termination condition
2. always call a case smaller than itself
All practical computations can be couched
in a recursive framework!
(see theory of computation) 3

4. Recursion Recursively defined structures e.g., binary tree Base case:
Empty tree has no nodes
Recursion:
None-empty tree has a root node with
two children, each the root of a binary tree 4

5. Recursion Widely used in CS and with trees... Mathematical recurrences
Recursive programs
Divide and Conquer
Dynamic Programming
Tree traversal
DFS

6. Recursive Algorithms
Recursive algorithm – solves problem by solving one or more smaller instances of same problem
Recurrence relation – factorial
N! = N(N-1)!, for N > 0, with 0! = 1.
In C++, use recursive functions
Int factorial(int N) {
if (N == 0) return 1;
return N*factorial(N-1); }

7. Recursive Algorithms BTW, can often also be expressed as iteration
E.g., can also write N! computation as a loop:
int factorial(int N) {
for (int t = 1, i = 1; i <= N; ++i)
t *= i;
return t; }

8. Euclid’s Algorithm
Euclid's Algorithm is one of the oldest known algorithms
Recursive method for finding the GCD of two integers
int gcd(int m, int n)
{ // expect m >= n
if (n == 0) return m;
return gcd(n, m % n); }
Base case
Recursive call to
smaller instance

9. Divide & Conquer Recursive scheme that divides input
into two (or some fixed number) of
(roughly) equal parts
Then makes a recursive call on each part
Widely used approach
Many important algorithms
Depending on expense of dividing and
combining, can be very efficient 9

10. Divide & Conquer Example: find the maximum element in an array a[N]
(Easy to do iteratively...)
Base case:
Only one element – return it
Divide:
Split array into upper and lower halves
Recursion:
Find maximum of each half
Combine results:
Return larger of two maxima 10

11. Divide & Conquer Property 5.1: A recursive function that divides
a problem of size N into two independent
(non-empty) parts that it solves, recursively
calls itself less than N times.
Prf:
T(1) = 0
T(N) = T(k) + T(N-k) + 1 for recursive call on
size N divided into one part of size k and the
other of size N-k
Induct! 11

12. Towers of Hanoi 3 pegs N disks, all on one peg
Disks arranged from largest on bottom to
smallest on top
Must move all disks to target peg
Can only move one disk at a time
Must place disk on another peg
Can never place larger disk on a smaller one
Legend has it that the world will end when a
certain group of monks finishes the task
in a temple with 40 golden disks on 3
diamond pegs

13. Towers of Hanoi
Target peg
Which peg should
top disk go on first?

14. Towers of Hanoi How many moves does this take?

15. Towers of Hanoi Property 5.2: The recursive d&c algorithm for the
Towers of Hanoi problem produces a solution
that has 2N – 1 moves.
Prf:
T(1) = 1
T(N) = T(N-1) T(N-1) = 2 T(N-1) + 1
= 2N – 1 by induction

16. Divide & Conquer Two other important D&C algorithms: Binary search
MergeSort
Algorithm
Metric
Recurrence
Approx. Soln.
Binary Search
comparisons
C(N) = C(N/2)+1
lg N
MergeSort
recursive calls
A(N) = 2 A(N/2) + 1 N
C(N) = 2 C(N/2) + N
N lg N 16

17. Dynamic Programming In Divide & Conquer, it is essential that the
subproblems be independent (partition the input)
When this is not the case, life gets complicated!
Sometimes, we can essentially fill up a table with
values we compute once, rather than
recompute every time they are needed.
This is Dynamic Programming
Issue – table may be too big!

18. Dynamic Programming Fibonacci Numbers:
F[N] = F[N-1] + F[N-2]
Horribly inefficient implementation:
int F(int N) {
if (N < 1) return 0;
if (N == 1) return 1;
return F(N-1) + F(N-2); }

19. Dynamic Programming How bad is this code?
How many calls does it make to itself?
F(N) makes F(N+1) calls!
Exponential!!!! 13 8 5 2 5 3 3 2 2 1 2 1 1 1 3 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

20. Dynamic Programming Can we do better? How?
Make a table – compute once (yellow shapes)
Fill up table 13 8 8 5 3 2 3 2 3 2 1 2 1 1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 3 4 5 6 7 8 1 1 2 3 5 8 13

21. Dynamic Programming Property 5.3: Dynamic Programming reduces
the running time of a recursive function to be
at most the time it takes to evaluate the functions
for all arguments less than or equal to the
given argument, treating the cost of a recursive
call as a constant.

22. Trees A mathematical abstraction Central to many algorithms
Describe dynamic properties of algorithms
Build and use explicit tree data structures
Examples:
Family tree of descendants
Sports tournaments (Who's In?)
Organization Charts (Army)
Parse tree of natural language sentence
File systems

23. Types of Trees Trees Rooted trees Ordered trees
M-ary trees and binary trees
Defn: A tree is a nonempty collection of vertices
and edges such that there is exactly one path
between each pair of vertices.
Defn: A path is a list of distinct vertices such that
successive vertices have an edge between them
Defn: A graph in which there is at most one path
between each pair of vertices is a forest.

24. Types of Trees root internal node leaf external node Binary Tree
Ternary Tree

25. Types of Trees
root
parent
node
sibling
child
Rooted Tree
Free Tree

26. Tree Representation
Binary Tree
Representation

27. Tree Representation Ordered Tree Representation Use linked list for
siblings at each level,
Pointer to left child

28. Properties of Trees A binary tree with N internal nodes has
N+1 external nodes
A binary tree with N internal nodes has 2N links:
N-1 to internal nodes and N+1 to external nodes
The level of a node is one higher than the level of
its parent, with the root at level 0.
The path length of a tree is the sum of the levels
of all the tree’s nodes
The internal path length is the sum of levels of
internal nodes; external path length is sum of
levels of external nodes.

29. Properties of Trees The external path length of any binary tree with N
nodes is 2N greater than the internal path length
The height of a binary tree with N internal nodes
is at least lg N and at most N-1.
The internal path length of a binary tree with N
internal nodes is at least N lg(N/4) and
at most N(N-1)/2.

30. Tree Traversal
Infix: Visit the left subtree, visit the root, then visit
the right subtree
Prefix: Visit the root, visit the left subtree, visit the
right subtree.
Postfix: Visit the left subtree, visit the right subtree,
visit the root.