Recursion
(CS 217)
Dr. Muhammad Aleem,
Department of Computer Science,
National University of Computer & Emerging Sciences,
Islamabad Campus
Introduction to Recursion
• A recursive function is one that calls itself.
void Message(void)
{
cout << "This is a recursive function.\n";
Message();
}
The above function displays the string
"This is a recursive function.\n", and then calls itself.
Can you see a problem with this function?
Recursion
• The function is like an infinite loop because there is
no code to stop it from repeating.
• Like a loop, a recursive function must have some
algorithm to control the number of times it repeats.
Recursion : Using Control Condition
void Message(int times)
{
if (times > 0)
{
cout << "This is a recursive function.\n";
Message(times - 1);
}
return;
}
The function contains an if/else statement that controls the
repetition. For example, if we call the function:
Message(5);
The argument, 5, will cause the function to call itself 5 times.
Recursion : Using Control Condition
void Message(int times)
{
if (times > 0) // Base case
{
cout << "This is a recursive function.\n";
Message(times - 1);
}
return;
}
• With each recursive call, the parameter controlling the
recursion should move closer to the base case
• Eventually, the parameter reaches the base case and the
chain of recursive calls terminates
void Message(int times)
{
if (times > 0)
1st call of the function
{
cout << "This is a recursive function.\n";
Value of times: 5 Message(times - 1);
}
2nd call of the function
return;
Value of times: 4 }
3rd call of the function
Value of times: 3
4th call of the function
Value of times: 2
5th call of the function
This cycle repeats itself
until 0 is passed to the Value of times: 1
function.
6th call of the function
Depth of recursion: 6 Value of times: 0
Program Output
This is a recursive function.
This is a recursive function.
This is a recursive function.
This is a recursive function.
This is a recursive function.
What Happens When Called?
• Each time a recursive function is called, a new copy of
the function runs, with new instances of parameters
and local variables being created
• As each copy finishes executing, it returns to the copy of
the function that called it
• When the initial copy finishes executing, it returns to
the part of the program that made the initial call to the
function
14-8
Types of Recursion
• Direct recursion
– a function calls itself
• Indirect recursion
– function A calls function B, and function B calls
function A. Or,
– function A calls function B, which calls …, which calls
function A
14-9
Recursive Function
#include <iostream>
using namespace std;
void message(int);
int main() {
message(5);
return 0;
}
//************************************************************
// Definition of function message. If the value in times is *
// greater than 0, the message is displayed and the function message
* called with 5 in times.
// is recursively called with the argument times - 1. This
* is a recursive function.
message
//************************************************************ called with 4 in times.
void message(int times) This is a recursive function.
{ cout << "message called with " << times message called with 3 in times.
This is a recursive function.
<< " in times.\n"; message called with 2 in times.
if (times > 0) This is a recursive function.
{ message called with 1 in times.
cout << "This is a recursive function.\n"; This is a recursive function.
message(times - 1); message called with 0 in times.
} message returning with 0 in times.
message returning with 1 in times.
message returning with 2 in times.
cout << "message returning with " << times; message returning with 3 in times.
cout << " in times.\n"; message returning with 4 in times.
return; message returning with 5 in times.
} Recursion
Recursion
To build all recursive functions:
1. Define the base case(s)
2. Define the recursive case(s)
a) Divide the problem into smaller sub-
problems
b) Solve the sub-problems
c) Combine results to get answer
Sub-problems solved
as a recursive call to
the same function
Creating a Sum Function
• sum(10) = 10+9+…2+1 = 55
Creating a Sum function (Iterative)
//Our initial total is zero
int total = 0;
//We want the sum from 1 + 2 + ... + 9 + 10
int n = 10;
/* The following for loop will calculate the summation
from 1 – n */
for ( int i = 1; i <= n; i++ ) {
total = total + i;
}
Creating a Sum function (Recursive)
int sum(int n) {
//Return 0 when n is 0
if ( n <= 0 )
return 0;
else //recursive call
return n + sum(n-1);
}
The Recursive Factorial Function
• The factorial of a non-negative integer n is the product of
all positive integers less or equal to n
• Factorial of n is denoted by n!
• The factorial of 0 is= 1
0!=1
n ! = n x (n-1) x … x 2 x 1 if n > 0
14-15
The Recursive Factorial Function
• Factorial of n can be expressed in terms of the
factorial of n-1
0!=1
n ! = n x (n-1) !
• The base case is n = 0
• Recursive function:
int factorial(int n)
{
if (n == 0)
return 1;
else
return n * factorial(n-1);
}
14-16
Character count - Recursive
int numChars(char search, char str[], int subscript)
#include
{ <iostream>
using ifnamespace std;
(str[subscript] == '\0')
{
// Function prototype
// Base case: The end of the string is reached.
int numChars(char, char [], int);
return 0;
}
int main()
else if (str[subscript] == search)
{
{
char array[] = "abcddddef";
/* Recursive case: A matching character was found.
Return 1 plus the number of times the search character
/* appears
Display in
the the
number
restofoftimes the letter
the string.*/
'd' appears in the string. */
return 1 + numChars(search, str,subscript+1);
}
cout << "The letter d appears "
else
<< numChars('d', array, 0) << " times.\n";
{
return /* 0;
Recursive case: A character that does not match the
search character was found. Return the number of times
} the search character appears in the rest of the string.
*/
return 0+ numChars(search, str, subscript+1); 14-17
}
}
Finding gcd
14-18
The Recursive gcd Function
int gcd(int x, int y)
{
if (x % y == 0) //base case
return y;
else
return gcd(y, x % y);
}
14-19
Solving Recursively Defined Problems
• The natural definition of some problems leads to
a recursive solution
• Example: Fibonacci numbers:
1, 1, 2, 3, 5, 8, 13, 21, ...
• After the starting 0,1, each term is the sum of
the two preceding terms
• Recursive solution:
fib(n) = fib(n – 1) + fib(n – 2);
• Base cases: n == 0, n == 1
14-20
Recursion
5th Fib. Number fib 5
fib 4 + fib 3
fib 3 + fib 2 fib 2 + fib 1
fib 2 + fib 1 fib 1 + fib 0 fib 1 + fib 0
fib 1 + fib 0
=8
Recursive Fibonacci Function
14-22
Printing a Sequence of Numbers in Reverse
void print(int n) {
if ( n <= 0 )
return; //Terminating condition
cout << n << " "; //Prints number n
print(n-1); //Calls itself with (n-1)
return; //Returns from the function
}
print(3) produces 3 2 1
Printing a Sequence of Numbers in
Ascending Order
Example:
Input Number: 5
Output: 1 2 3 4 5
Recursive Algorithms… Examples
– The Towers of Hanoi
– Binary Search Algorithm
– Height of a Binary Tree
–…
You will study in DS and Algorithm courses.
14-26
Printing Patterns using Recursion
14-27
Printing Patterns using Recursion
Code credits: https://www.geeksforgeeks.org/
14-28
Printing Patterns using Recursion
Input:
Draw a Pyramid of size: 5
Output:
14-29
Printing Patterns using Recursion
Code credits: https://www.tutorialspoint.com/
14-30
The Towers of Hanoi
• Setup: 3 pegs, one has n disks on it, the other two pegs
empty. The disks are arranged in increasing diameter:
top bottom
• Objective: move the disks from peg 1 to peg 3:
– only one disk moves at a time
– all remain on pegs except the one being moved
– a larger disk cannot be placed on top of a smaller disk
at any time
14-31
The Towers of Hanoi
How it works:
n=1 Move disk from peg 1 to peg 3.
Done.
n=2 Move top disk from peg 1 to peg 2.
Move remaining disk from peg 1 to peg 3.
Move disk from peg 2 to peg 3.
Done.
14-32
Moving Three Discs
Outline of Recursive Algorithm
If n==0, do nothing (base case)
If n>0, then
a. Move the topmost n-1 disks from peg1 to peg2
b. Move the nth disk from peg1 to peg3
c. Move the n-1 disks from peg2 to peg3
end if
14-34
Recursion
37
Recursion VS. Iteration
• Benefits (+), disadvantages(-) of Recursive
Implementation
+ Natural formulation of solution to certain problems
+ Results in shorter, simpler functions
– May not execute very efficiently
• Benefits (+), disadvantages(-) for iterative
Implementation
+ Executes more efficiently than recursion
– May not be as natural as recursion for some problems
14-38
