1 recursion dr. bernard chen ph.d. university of central arkansas
TRANSCRIPT
1
Recursion
Dr. Bernard Chen Ph.D.University of Central Arkansas
2
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 >=1 , p(k+1) is true whenever p(k) is true then p(n) is true for all n>=1 .
• 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(k+1)
Induction step. --- prove p(k+1) is true based on IH
3
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)
4
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
5
General format forMany Recursive Functions
if (some easily-solved condition) // base case
solution statement
else // general case
recursive function call
6
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.
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 function’s 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 function’s 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
int Func ( /* in */ int a, /* in */ int b ){ int result; if ( b == 0 ) // base case
result = 0;else if ( b > 0 ) // first general case result = a + Func ( a , b - 1 ) ) ; // instruction 50
return result; }
A recursive function
11
FCTVAL ? result ? b 2 a 5Return Address 100
Run-Time Stack Activation Records
x = Func(5, 2);// original call at instruction 100
original call at instruction 100 pushes on this record for Func(5,2)
12
FCTVAL ? result ? b 1 a 5Return Address 50
FCTVAL ? result 5+Func(5,1) = ? b 2 a 5Return Address 100
record for Func(5,2)
call in Func(5,2) codeat instruction 50 pushes on this recordfor Func(5,1)
Run-Time Stack Activation Records
x = Func(5, 2);// original call at instruction 100
13
FCTVAL ? result ? b 0 a 5Return Address 50
FCTVAL ? result 5+Func(5,0) = ? b 1 a 5Return Address 50
FCTVAL ? result 5+Func(5,1) = ? b 2 a 5Return Address 100
record for Func(5,2)
record for Func(5,1)
call in Func(5,1) codeat instruction 50pushes on this record for Func(5,0)
Run-Time Stack Activation Records
x = Func(5, 2);// original call at instruction 100
14
FCTVAL 0 result 0 b 0 a 5Return Address 50
FCTVAL ? result 5+Func(5,0) = ? b 1 a 5Return Address 50
FCTVAL ? result 5+Func(5,1) = ? b 2 a 5Return Address 100
record for Func(5,0)is popped first with its FCTVAL
record for Func(5,2)
record for Func(5,1)
Run-Time Stack Activation Records
x = Func(5, 2);// original call at instruction 100
15
record for Func(5,2)
record for Func(5,1)is popped nextwith its FCTVAL
FCTVAL 5 result 5+Func(5,0) = 5+ 0 b 1 a 5Return Address 50
FCTVAL ? result 5+Func(5,1) = ? b 2 a 5Return Address 100
Run-Time Stack Activation Records
x = Func(5, 2);// original call at instruction 100
16
FCTVAL 10 result 5+Func(5,1) = 5+5 b 2 a 5Return Address 100
record for Func(5,2)is popped lastwith its FCTVAL
Run-Time Stack Activation Records
x = Func(5, 2);// original call at instruction 100
Let’s try an example
17
18
Too much recursion Can Be Dangerous
Fibonacci numbers.
Long fib (int n)
{
If (n <=1)
return n;
Else
return fib(n-1) + fib(n-2);
}
19
Too much Recursion Can be Dangerous
This definition will lead to exponential running time.
Reason:
-- too much redundant work Not necessary to use recursive
Write a non-recursive Fibonacci code
20
Fibonacci
21
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.
22
Traversal Three standard traversal order
preorder - V L R inorder - L V R postorder - L R V
Preorder: traverse the node itself first, then all nodes in the LEFT subtree , 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.
Inorder: traverse all nodes in the LEFT subtree first, then the node itself, then all nodes in the RIGHT subtree.
Inorder: traverse all nodes in the LEFT subtree first, then the node itself, 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,
Postorder: traverse all nodes in the LEFT subtree first, then all nodes in the RIGHT subtree, then the node itself,
V
RL
23
Recursive Traversal Implementation
Void PrintInorder (root) if root != null PrintInorder(root->left); print(root->data); PrintInorder(root->right); endif;
Void PrintInorder (root) if root != null PrintInorder(root->left); print(root->data); PrintInorder(root->right); endif;
The difference is the order of the three statements in the ‘IF’.
The difference is the order of the three statements in the ‘IF’.
1
2 3
4 5 6
preorder : 1 2 4 5 3 6inorder : 4 2 5 1 3 6postorder : 4 5 2 6 3 1
preorder : 1 2 4 5 3 6inorder : 4 2 5 1 3 6postorder : 4 5 2 6 3 1
Void PrintPreorder (root) if root != null print(root->data); PrintPreorder(root->left); PrintPreorder(root->right); endif;
Void PrintPreorder (root) if root != null print(root->data); PrintPreorder(root->left); PrintPreorder(root->right); endif;
Void PrintPostorder (root) if root != null PrintPostorder(root->left); PrintPostorder(root->right); print(root->data); endif;
Void PrintPostorder (root) if root != null PrintPostorder(root->left); PrintPostorder(root->right); print(root->data); endif;
Binary Search 3-ways comparisonsint binarySearch(vector<int> a[], int x){
int low = 0;int high = a.size() – 1;
int mid;while(low <= high) {
mid = (low + high) / 2;if(a[mid] < x)
low = mid + 1;else if( a[mid] > x)
high = mid - 1;else
return mid;}return NOT_FOUND; // NOT_FOUND = -1
}//binary search using three-ways comparisons
25
Some more examples:
Factorials Binary Search template <class Comparable> int binarySearch( const vector<Comparable> & a,
const Comparable & x, int low, int high ) { if( low > high ) return NOT_FOUND; int mid = ( low + high ) / 2; if( a[ mid ] < x ) return binarySearch( a, x, mid + 1, high ); else if( x < a[ mid ] ) return binarySearch( a, x, low, mid - 1 ); else return mid; }
26
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.
27
Recursion or Iteration?
EFFICIENCYCLARITY