Recursion

1
Recursion

• Dr. Bernard Chen Ph.D.
• University of Central Arkansas
• Fall 2008

2
Recursive Function Call

• a recursion function is a function that either
  directly or indirectly makes a call to itself.
• but we need to avoid making an infinite sequence
  of function calls (infinite recursion)

3
Finding a Recursive Solution

• a recursive solution to a problem must be written
  carefully
• the idea is for each successive recursive call to
  bring you one step closer to a situation in which
  the problem can easily be solved
• this easily solved situation is called the base
  case
• each recursive algorithm must have at least one
  base case, as well as a general (recursive) case
  

4
Mathemetical Induction

• To prove

• Let p(n) denote the statement involving the
  integer variable n. The Principle of Mathematical
  Induction states
• If p(1) is true and, for some integer K gt1 ,
  p(k1) is true whenever p(k) is true then p(n) is
  true for all ngt1 .
• 4 steps in using Induction
• Base cases --- p(1), p(2),
• Induction hypothesis (IH) --- assume p(k) is
  true
• Statement to be proved in induction --- it is
  true for p(k1)
• Induction step. --- prove p(k1) is true based
  on IH

5
A recursive definition

• int s (int n)
• if (n 1)
• return 1
• else
• return s(n-1) n

• A few of problems
• n ? 0 at the beginning
• return value might be too large to fit in an int.

6
General format forMany Recursive Functions

• if (some easily-solved condition) // base
  case
• solution statement
• else // general case
• recursive function call

7
When a function is called...

• a transfer of control occurs from the calling
  block to the code of the function--it is
  necessary that there be a return to the correct
  place in the calling block after the function
  code is executed this correct place is called
  the return address
• when any function is called, the run-time stack
  is used--on this stack is placed an activation
  record for the function call

8
Stack Activation Frames

• the activation record contains the return address
  for this function call, and also the parameters,
  and local variables, and space for the functions
  return value, if non-void
• the activation record for a particular function
  call is popped off the run-time stack when the
  final closing brace in the function code is
  reached, or when a return statement is reached in
  the function code
• at this time the functions return value, if
  non-void, is brought back to the calling block
  return address for use there

9
A Stake of Activation Records
S(1)
S(2)
S(3)
S(4)
Main()
10
A recursive function

• int Func ( / in / int a, / in / int
  b )
• int result
• if ( b 0 ) // base
  case
• result 0
• else if ( b gt 0 ) // first
  general case
• result a Func ( a , b - 1 ) ) //
  instruction 50
• return result

11
Run-Time Stack Activation Records
x Func(5, 2)//
original call at instruction 100
FCTVAL
? result
? b 2
a 5 Return
Address 100
original call at instruction 100 pushes on this
record for Func(5,2)
12
Run-Time Stack Activation Records
x Func(5, 2)//
original call at instruction 100
FCTVAL ?
result ?
b 1
a 5 Return Address 50
FCTVAL ?
result 5Func(5,1) ?
b 2 a
5 Return Address 100
call in Func(5,2) code at instruction 50 pushes
on this record for Func(5,1)
13
Run-Time Stack Activation Records
x Func(5, 2)//
original call at instruction 100
call in Func(5,1) code at instruction 50 pushes
on this record for Func(5,0)
FCTVAL ?
result ?
b 0 a
5 Return Address 50
FCTVAL ?
result 5Func(5,0) ?
b 1 a
5 Return Address 50
FCTVAL ?
result 5Func(5,1) ?
b 2 a
5 Return Address 100
14
Run-Time Stack Activation Records
x Func(5, 2)//
original call at instruction 100
FCTVAL 0
result 0
b 0 a
5 Return Address 50
FCTVAL ?
result 5Func(5,0) ?
b 1 a
5 Return Address 50
FCTVAL ?
result 5Func(5,1) ?
b 2 a
5 Return Address 100
record for Func(5,0) is popped first with its
FCTVAL
record for Func(5,1)
record for Func(5,2)
15
Run-Time Stack Activation Records
x Func(5, 2)//
original call at instruction 100
FCTVAL 5
result 5Func(5,0) 5 0
b 1
a 5 Return Address
50 FCTVAL
? result 5Func(5,1) ?
b 2
a 5 Return Address
100
record for Func(5,1) is popped next with its
FCTVAL
record for Func(5,2)
16
Run-Time Stack Activation Records
x Func(5, 2)//
original call at instruction 100
FCTVAL
10 result 5Func(5,1)
55 b 2
a 5 Return
Address 100
record for Func(5,2) is popped last with its
FCTVAL
17
Too much recursion Can Be Dangerous
Fibonacci numbers. Long fib (int n) If
(n lt1) return n Else return
fib(n-1) fib(n-2)
18
Too much Recursion Can be Dangerous

• This definition will lead to exponential running
  time.
• Reason
• -- too much redundant work
• Not necessary to use recursive

19
Tree

• Tree is a fundamental structure in computer
  science.
• Recursive definition A tree is a root and zero
  or more nonempty subtrees.
• Nonrecursive definition A tree consists of s set
  of nodes and a set of directed edges that connect
  pairs of nodes. That is, a connected graph
  without loop.

20
Traversal

• Three standard traversal order
• preorder - V L R
• inorder - L V R
• postorder - L R V

Inorder traverse all nodes in the LEFT subtree
first, then the node itself, then all nodes in
the RIGHT subtree.
Preorder traverse the node itself first, then
all nodes in the LEFT subtree , then all nodes in
the RIGHT subtree.
Postorder traverse all nodes in the LEFT subtree
first, then all nodes in the RIGHT subtree, then
the node itself,
21
Recursive Traversal Implementation
Void PrintPreorder (root) if root ! null
print(root-gtdata) PrintPreorder(root-
gtleft) PrintPreorder(root-gtright)
endif
preorder 1 2 4 5 3 6 inorder 4 2 5 1 3
6 postorder 4 5 2 6 3 1
Void PrintInorder (root) if root ! null
PrintInorder(root-gtleft)
print(root-gtdata) PrintInorder(root-gtrigh
t) endif
Void PrintPostorder (root) if root ! null
PrintPostorder(root-gtleft)
PrintPostorder(root-gtright)
print(root-gtdata) endif
The difference is the order of the three
statements in the IF.
22
Some more examples

• Factorials
• Binary Search
• template ltclass Comparablegt int binarySearch(
  const vectorltComparablegt a, const Comparable
  x, int low, int high )
• if( low gt high )
• return NOT_FOUND
• int mid ( low high ) / 2
• if( a mid lt x )
• return binarySearch( a, x, mid 1,
  high )
• else if( x lt a mid )
• return binarySearch( a, x, low, mid
  - 1 )
• else return mid

23
Divide and Conquer

• Given an instance of the problem to be solved,
  split this into several, smaller, sub-instances
  (of the same problem) independently solve each of
  the sub-instances and then combine the
  sub-instance solutions so as to yield a solution
  for the original instance.

24
Recursion or Iteration?
EFFICIENCY
CLARITY