Talk Binary » recursion

C++ Recursion

Diego — Tue, 20 Jul 2010 16:54:41 +0000

Recursion in C++ is a function with a set of rules designed to reduce a problem into a smaller one called a base case. This may be referred to as the divide and conquer method since the idea is to solve a complex problem by solving the smaller instances of it. A classic example is the factorial function, which we’ll discuss later.

Recursive function that displays numbers

For our first example, let’s create a recursive function that displays a number. In order to do this, we create a function that prints a number to output, then we call itself.

void printnum(int n)
{
     cout << n << " ";
     printnum(n); // Recursive call
     return;
}

Unfortunately, the previous example displays behavior known as infinite recursion on any call. Depending on the environment you are programming in, you might receive a segmentation fault. This happens because each activation record of a function is pushed onto the run-time stack. When you have a function that runs indefinitely, you are bound to run out of space.

Example of Infinite Recursion

Base Cases in Recursion

In order to eliminate infinite recursion we introduce a base case. A base case is a condition that determines when to terminate a recursive function. For our previous example, we’ll introduce the following base case and also make sure we are reducing our input into a smaller case each call (otherwise, we’d never reach our base case).

void printnum(int n)
{
     // Base case
     if ( n == 0 ) 
          return;
     cout << n << " ";
 
     // Recursive call that reduces input into a smaller case
     printnum(n-1); 
     return;
}

Below is an example of the output of executing such a function.

1	printnum(5);

5 4 3 2 1

Example of printnum(3) and output to the console

Now, what happens if we execute printnum(-2)? We will never reach our base case and thus receive infinite recursion. In order to avoid this behavior, its essential that we create robust base cases that allow our recursive functions to terminate.

The following is the modified version of our recursive function.

void printnum(int n)
{
     // Improved base case 
     if ( n <= 0 ) 
          return;
     cout << n << " ";
 
     // Recursive call that reduces input into a smaller case
     printnum(n-1);
     return; 
}

Things to remember about C++ Recursion

Below are some things that you should take into consideration when solving recursive problems in C++.

Recursion in C++ is a very difficult subject. It takes dedication in order to understand and master the subject.

The best way to solve recursive functions is to write down the problem on a piece of paper and identify how you are going to break down the problem into a smaller instance and when to terminate (base cases).

A good way to visualize recursion is to draw the activation records by drawing the run time stack of a simple recursive call

Going further with C++ Recursion

Now that you know the basic concept, the best way to learn recursion is by solving problems.

Next: C++ Recursion Examples

C++ Recursion Examples

Diego — Mon, 29 Mar 2010 05:10:58 +0000

C++ Recursion Examples

Recursion is often one of those topics in programming that many people fail to grasp immediately due to its nature. If you don’t remember, recursion in C++ is simply a function that calls itself that terminates when a base case is met.

But, why can learning this subject be difficult? Since a recursive function may have many and often an unknown amount of recursive calls, its difficult to trace its behavior. The biggest mistake I see when people try to create or traverse these functions, is when they try to do it in their head. If you are a beginner, I recommend you to get rid of this habit and learn to write your ideas down. Trust me, you’ll save yourself time.

The recursive calls of Fibonacci when n = 4

Getting Started

Below are a couple of examples to help you learn the process. Before you view them, try working them out on your own. This is always the best way since you’ll develop a method you’ll always remember. Only once you gave it your best effort and couldn’t solve it, go through the examples. Make sure you understand the thought process presented, because once you understand it writing recursive functions should be a lot easier.

Beginner C++ Recursion Examples

Below are some basic examples using recursion. These should teach you the basics on base cases, and return statements.

Printing a Sequence of Numbers in Reverse

By now you should know how to print a sequence of numbers using recursion. What about printing this same sequence in reverse? This should require a minor change to your previous recursive function.

C++ Recursion – Printing a sequence of numbers in reverse

Summation

Let’s try doing some math using recursion. Can you create a function that computes the summation of 0, 1, …, n – 1, n ? This basic recursive function should help you understand how recursion can be used.

Example:
[pmath]Sum(5) = 5 + 4 + 3 + 2 + 1 = 15[/pmath]

C++ Recursion – Summation

Factorial

Did you understand how the summation function worked using recursion? Try making a function that computes n factorial.

Example:
[pmath]5! = 5 * 4 * 3 * 2 * 1 = 120[/pmath]

C++ Recursion – Factorial

Intermediate C++ Recursion Examples

These intermediate examples require a little bit more thinking since you are dealing with more parameters into your function headers.

Power

Now that you have a good grip of simple recursive functions, try your hand at something a little bit more difficult.

Example:
[pmath]2^5 = 2 * 2 * 2 * 2 * 2 = 32[/pmath]

C++ Recursion – Power

Greatest Common Divisor

Can you determine the greatest common divisor or two numbers? The example is done using Euler’s formula.

Example:
[pmath] gcd(12,36) = 12 [/pmath]

C++ Greatest Common Divisor

Logarithm

Previously we asked you to do a Power function, now something similar. Try doing the logarithm of base 2, and of base n.

Example:
[pmath]2^n = 8, n = 3 [/pmath]

[pmath]4^n = 64, n = 3[/pmath]

C++ Recursion – Logarithm

Fibonacci

Given a definition of a math function, could you come up with a recursive function?

[pmath] Fibonacci(0) = 0 [/pmath]
[pmath] Fibonacci(1) = 1 [/pmath]
[pmath] Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)[/pmath]

C++ Recursion – Fibonacci

Advanced C++ Recursion Examples

The following recursive functions are a little more complex since they require a bit more of planning.

Reverse elements of a vector

Given a vector, can you reverse the order of the elements using recursion?

C++ Recursion – Reverse elements of a vector

Determining if a string is a palindrome

Can you determine if a string is a palindrome? A palindrome is a string that can be read the same both forward and backwards such as racecar, mom, and abba.

C++ Recursion – Palindrome

Binary Search

Can you perform binary search using recursion?

C++ Recursion – Binary Search

Going Further

Remember, practice makes perfect. Recursion is a difficult subject so don’t give up early. Just make sure you develop a method to tackle recursion. Once you have one down, recursion shouldn’t give you trouble.

If you wish to see more examples, post them below.

What is faster, an iterative or a recursive version of a function? And why?
Can you do Bubble Sort using recursion?
Can you do Merge Sort?
Is there a way to make Fibonacci require less calls?

C++ Recursion – Palindrome

Diego — Thu, 11 Mar 2010 06:30:38 +0000

Determining if a string is a Palindrome using recursion

Below is an example of how to determine if a word is a palindrome using recursion. A Palindrome is a string that could be read the same way in either direction such as racecar, mom, and even a. This tutorial expects you to understands the following.

C++ Recursion

Example of finding if a word is a palindrome

To determine if a word is a palindrome do the following.

Compare the first and last character

If these characters are the same, disregard these characters and repeat until one one character or no characters remain

Example:
// Check first and last character
[ r ] [ a ] [ c ] [ e ] [ c ] [ a ] [ r ] 

// Second iteration
[ a ] [ c ] [ e ] [ c ] [ a ] 

// Third iteration
[ c ] [ e ] [ c ]  

// Fourth iteration
[ e ]

// The word is a palindrome.
Now let’s try one that isn’t a palindrome.
// First iteration
[ t ] [ a ] [ b ] [ t ]

// In our second iteration, a and b don't match
[ a ] [ b ]

Creating an is Palindrome function using recursion

There are multiple ways to create a recursive function. Try coming up with your own before seeing the one below. As always, we’ll start with the function header.

Function header for is Palindrome

We’ll be using the following function header.
bool isPalindrome(string word); 
You may ask, do we need more parameters? Not necessarily. Think substr.

Base Cases for is Palindrome

If you recall we had three base cases.

If the first and last character don’t match, the word is not a palindrome

If the word contains one or no characters, the word is a palindrome
bool isPalindrome(string word) { 

      int strlen = word.size();

     // Base Case #1
     if ( word[0] != word[strlen - 1] )
         return false;

     // Base Cases #2, #3
     else if ( strlen <= 1 )
          return true;
We store the length of the word so we don't have to be recomputing it more than once. You'll see why later.

Recursive call for is Palindrome

If you also recall from our initial example, if the first and last character match, we disregard them in our next comparison. How do we call isPalindrome with this new word? Think substr.

Substr returns a substring of a string

substr returns a substring of a string.
bool isPalindrome(string word) { 

      int strlen = word.size();

     // Base Case #1
     if ( word[0] != word[strlen - 1] )
         return false;

     // Base Cases #2, #3
     else if ( strlen <= 1 )
          return true;

     // At this point we know the characters matched
     else
          return isPalindrome(word.substr(1, strlen - 2));

}
Why do we return a substring with the following parameters? If you don't recall how substr works, simply follow the next explanation. In essence, at each recursive call we are reducing the strings in the same way shown in the explanation.

string::subtr

The substr functions returns a substring with the following parameters of the current object.

Paramters of substr

pos - Start position of the character of the current word

n - Length of the substring starting from the start position pos.

Return value of substr

A string containing the substring of the object.

Example usage of substr
string msg = "racecar";

cout << msg << endl;

// Our new substr should start at position 1 and be of size 5
// which is shown below.
//
// [ r ] [ a ] [ c ] [ e ] [ c ] [ a ] [ r ]
//        | S                              |
string new msg = msg.substr(1, msg.size()-2);

cout << newmsg << endl;
Will result in the following.
racecar

aceca
This should make you understand how the recursive calls are made to determine if the word is a palindrome.

Going further

Can you apply this using a vector?

C++ Recursion – Reverse elements of a vector

Diego — Mon, 08 Mar 2010 22:09:48 +0000

Reversing the elements of a vector using recursion

Below is an example of how to reverse the elements of a vector using recursion. This tutorial expects you to understand the following.

C++ Recursion

Example of reversing the elements of a vector

Below is an example of how one would reverse the elements of a vector by simply intuition.
// Our vector with size 5
[ X ] [ B ] [ A ] [ N ] [ Y ]
[ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 4 ]

//Step 1: Swap entry 0 (first) with the entry n (last)
[ Y ] [ B ] [ A ] [ N ] [ X ]
[ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] 

//Step 2: Swap entry 1 with entry 3 (n -1)
[ Y ] [ N ] [ A ] [ B ] [ X ]
[ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 4 ]

//Step 3: No swap needed for 3rd entry (or middle entry)
[ Y ] [ N ] [ A ] [ B ] [ X ]
[ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 4 ]
Notice how once we arrive at the entry in the middle of the vector we don’t continue. Why? The values beyond this entry have already been swapped. Keep this in mind.

Reversing the elements of a vector using iteration

Before we try making a recursive function to reverse the elements of a vector, let’s make one using iteration. By following the method described in the method above, it’s easy to see that we are simply swapping the ith and (nth – ith) variables (Example: the 0th and the 4th (4th – 0th) element).

Reversing the elements of a vector using iteration

The iterative solution for reversing the elements of a vector is below. Make sure you are trying all these functions if you haven’t before on your own.
//We pass the vector by reference
void reverseElements(vector  &vec) {

     //Temp variable for swapping
     int temp;

     int n = vec.size()-1;

     //Iterate vec.size()/2 times
     for ( int i = 0; i < vec.size()/2; i++ ) {

          // The swapping of elements
          temp = vec[i];
          vec[i] = vec[n-i];
          vec[n] = temp;

     }

     return;
}
Make sure you understand this completely before moving forward. Try working it out by hand.

Reversing the elements of a vector using recursion

So how would we start? What would the function header be?

Function header for reversing elements of a vector

So what would we need for our function header? We need the vector of course and also passed in by reference. Then we also need a way of knowing the two elements that are going to be swapped.
void revVector(vector  &vec, int lo, int hi);

// Which would be called with the following //
vector  a;

// Populate a...

revVector(a, 0, a.size()-1);
We'll name this revVector for know and the two variables to be swapped lo and hi. How are we going to use these two variables? Every new recursive calls we will increase lo and decrease hi until our base case.

So what would be our base case?

Base case for reversing elements of a vector

Your first guess might be
if ( lo == hi ) return; 
But, what if we have an even number of entries? This wouldn't be the case. Let's refine it.
if ( lo >= hi ) return; 
Now that would take care of when the vector is of even or odd size. Why? Try figuring it out if you haven't.

Below is the rest of the function.

Solution

void revVector(vector  &vec, int lo, int hi) {

     // First base case //
     if ( lo >= hi ) return;

     // The swapping
     int temp;
     temp = vec[lo];
     vec[lo] = vec[hi];
     vec[hi] = temp;

     // Next recursive call increase lo, and decrease hi by 1
     revVector(vec, lo+1, hi-1);

     return;
}

Going further

Can you make a helper function for this recursive function? [Hint: C++ Helper Functions]
Can you write a function that does the swap which would be called within your recursive/iterative version?

C++ Recursion – Greatest Common Divisor

Diego — Mon, 08 Mar 2010 05:32:49 +0000

Greatest Common Divisor using the Euclidean Algorithm

Below is an example of how to create the recursive function of computing the greatest common divisor using the Euclidean Algorithm.

* This tutorial assumes you understand the following.

Introduction to Recursion in C++

Euclid’s Algorithm

When studying computer science a famous algorithm taught to students is the Euclidean Algorithm which is used to compute the greatest common divisor of two integers. It’s definition is below.

[pmath] gcd(x,y) [/pmath]

Computing various examples

So how does it work? Well, let’s follow the definition, but before doing that, do you remember how to compute the remainder of two integers in c++? If you don’t, well it’s the % (mod) operator.

// Computing the gcd of 45 and 9 //
gcd(45, 9) 
= gcd(9, 45 % 9 ) = gcd(9, 0) 
= 9
 
 
// Computing the gcd of 54 and 12 //
gcd(54, 12)
= gcd(12, 54 % 12) = gcc(12, 6) 
= gcd(6, 12 % 6) = gcd(6, 0)
= 6

Now that you saw how this works, try creating the recursive function for the greatest common divisor by simply using the definition. [Hint: Treat the Conditions as your base cases]

Recursive function of Greatest Common Divisor

The solution for the function is below. If you notice you’ll see that the definition was simply translated into a recursive c++ function aside from an additional base case that handles erroneous input.

int gcd(int x, int y) { 
 
     // Condition 1 //
     if ( y == 0 ) 
          return x; 
 
     // Condition 2 // 
     else if ( x >= y && y > 0 ) 
          return gcd(y, x%y);
 
     // If not condition was met return error //
     else 
         return -1;
}

Going further

Can you figure a way to make sure x is always the larger value? [Hint: C++ Helper Functions]
Can you write the iterative version?

C++ Recursion – Fibonacci

Diego — Wed, 24 Feb 2010 06:41:24 +0000

The Fibonacci Sequence

Below is an example of how to create the recursive version of the Fibonacci sequence. But first of all, what is it?

* This tutorial assumes you understand the following:

Introduction to Recursion in C++

Fibonacci is a well known number sequence that models the growth of a rabbit population amongst other things found in nature.

Below is the Fibonacci numbers computed up to the 11th term.

0	1	2	3	4	5	6	7	8	9	10	11
0	1	1	2	3	5	8	13	21	34	55	89

Iterative version of Fibonacci

Before we create the recursive version of Fibonacci, let’s look at how to create the iterative version by looking at the formula.

Fibonacci Formula

Fibonacci(0) = 0;
Fibonacci(1) = 1;
Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2);

So how would we do an iterative version? I’ll walk you through the code.

// The value of n is the Fibonacci number we want to compute //
int fibonacci(int n) { 
 
    //Our two initial values
    int fib1 = 0;
    int fib2 = 1; 
 
 
    //Our running value
    int fibn = fib1 + fib2;
 
    // Computing the nth value of Fibonacci //
    // Explained below //
 
   return fib;

So how would we compute the value of the nth value of the Fibonacci sequence? We can do it with a for loop, to add UP to the value we are looking for. In other words, if we were doing it by hand, we’d do it as following:

//Initial cases
fib(0) = 0;
fib(1) = 1;
 
fib(2) = fib(1) + fib(0) = 1 + 0 = 1;
 
fib(3) = fib(2) + fib(1) = 1 + 1 = 2;
 
fib(4) = fib(3) + fib(2) = 2 + 1 = 3;
 
fib(5) = fib(4) + fib(3) = 3 + 2 = 5; 
 
fib(6) = fib(5) + fib(3) = 5 + 3 = 8;
 
..
 
fib(n) = fib(n - 1) + fib(n-2);

You could think of fib(n), fib(n-1), and fib(n-2) being fib, fib1, and fib2 respectively in our code. Try coming up with a solution to compute the nth Fibonacci number.

The code to compute the Fibonacci sequence for iterative version is below.

// The value of n is the Fibonacci number we want to compute //
int fibonacci(int n) { 
 
    //Our two initial values
    int fib1 = 0;
    int fib2 = 1; 
 
    //Our running value
    int fib = fib1;
 
    // Computing the nth value of Fibonacci //
    for ( int i = 1; i < n; i++ ) 
    { 
        // Fib(n) = fib(n-1) + fib(n-2);
        fib = fib1 + fib2;
 
        // The next two numbers are set this way 
        // to be used in the next computation of fib(n) 
        // Work it out by hand if you don't understand it.
 
        // Fib(n-1) = fib(n-2)
        // Fib(n-2) = fib
        fib1 = fib2;
 
        fib2 = fib;
    }
 
   // Return result
   return fib;

Recursive version Fibonacci

To create the recursive version of Fibonacci, we start like always with the base cases. In case you forgot, the formula for Fibonacci is below.

Fibonacci Formula

Fibonacci(0) = 0;
Fibonacci(1) = 1;
Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2);

So let’s start by creating the base case and function header.

int fibonacci(int n) {
 
    // Base cases
    if ( n == 0 ) return 0;
    else if ( n == 1 ) return 1;
 
}

That was quite simple wasn’t it? An image describing the function calls are below.

So how do we go on by computing the nth term of the Fibonacci sequence? Try it out on your own first then come back. If you translated the formula correctly into code, it should then look like the following.

int fibonacci(int n) {
 
    // Base cases
    if ( n == 0 ) return 0;
    else if ( n == 1 ) return 1;
 
    //This is returning fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)
    else 
         return fibonacci(n-1) + fibonacci(n-2);
 
}

Explanation of Fibonacci using Recursion

Yes, that is surprisingly it. Now you see why recursion can make our life a bit easier sometimes? If you don’t understand how it works, look at the following set of images. Try drawing them out by hand to understand how they work.

The following image shows you how the recursive calls would be made with larger n values.

Overview of Fibonacci Sequence using Recursion

If you still don’t understand how it works, my best encouragement is to draw the function calls by hand. Try doing something similar to my drawings. Recursion is a tough topic so it takes some time to learn. Even I struggled with the subject.

If you have any questions or suggestions, feel free to post them below.

C++ Recursion – Printing Elements of a Vector

Diego — Sun, 21 Feb 2010 08:05:33 +0000

Printing elements of a Vector using Recursion

Below is an example of how to print the elements of a vector using recursion. Later, we’ll print the elements in reverse. Why is this useful? You can apply this principle later to more complex data structures such as Binary Search Trees, or Linked Lists.

This tutorial assumes you understand the following:

Iterative version for printing elements of a vector

To understand how to print elements of a vector using recursion, let’s write a simple algorithm that will do it for us using iteration.

void printVector(vector  vec) { 

     for ( int i = 0; i < vec.size(); i++ ) { 

          //Printing ith element  followed by a space
          cout << vec[i] << " ";

     }

     //Printing end line
     cout << endl;
}

Recursive function for printing elements of a vector

So, how do we go from iteration to recursion? Well if you remember how to Print a Sequence of Numbers using Recursion without a vector, you know at every recursive call we print an number larger than the previous. In this case we want to print out an element in the vector in increasing order. So what would be our function header?

void printVector(vector  vec) {

Would this work? Well if you think about it, which element would you print? Using iteration, we used the i variable to print the ith element in the vector. Using recursion, we would simply pass this variable, so our function header would be the following.

void printVector(vector  vec, int i) {

Now, using the knowledge of Printing a Sequence of Numbers using Recursion we could apply this to printing a sequence of elements in a vector.

void printVector(vector vec, int i) { 

     //Returning when i is larger or equal to the size
    //of the vector
     if ( i >= vec.size() ) {
          return;
     }

     //Printing the ith element of the vector
     cout << vec[i] << " ";

     //Calling the function with a larger i
     printVector(vec, i+1);
}

Using this function would be done using the following.

vector  vec; 

//Populate vector...

//Calling the printVector function
printVector(vec, 0);

Have any questions? Feel free to ask below or request any other examples.

Going further

1. How would you make this function's base case take care of another case where your program might crash? (Hint: What is your function was called with a different i value?)
2. How would you make this function be called by simply passing in the vector and not the element to be printed first (in our example, 0). (Hint: Use Helper functions)
3. How would you print the elements of the vector in reverse? (Hint: Printing a sequence of numbers in reverse)

C++ Recursion – Power Continued

Diego — Fri, 12 Feb 2010 06:35:04 +0000

Creating a power function using Recursion

So, previously we tried computing the Power function using recursion but we didn’t take into account when the exponent was negative. This continues the previous function, so if you haven’t yet, go back. Make sure you understand the following as well:

Power Function using Recursion

Below is our previous power function which takes into account only positive exponents. So how would we go on by taking into account negative exponents?

int power(int base, int exp) {

     //Return 1 when n is 0
     if ( n == 0 )
          return 1;
     else if ( n == 1 )
           return base;
     else
          return base * power(base, exp-1);
     int result = base;

}

Let’s start by coming up with a formula again.

power(2,-1) = (1/2);

power(2,-2) = (1/2) * power(2, -1) = (1/2) * (1/2) = (1/4);

power(2,-3) = (1/2) * power(2,-2) = (1/2) * (1/4) = (1/8);

power(2,-4) = (1/2) * power(2,-3) = (1/2) * (1/8) = (1/16);

...

//Until exp == -1
power(base, -exp) = (1/base) * power(base, exp+1);

Taking into account negative exponents

So now that we have a formula, what would be our base case? We surely don’t want our previous base case to return 1 when (n==0) because that would be wrong.

if ( exp == -1 ) return (1/base);

Then simply applying the formula to do the computation of other values below -1:

int power(int base, int exp) {

      if ( n < - 1)
          return (1/base) * power(base, exp+1);
     else if ( n == -1 )
          return (1/base);
     //Return 1 when n is 0
     else if ( n == 0 )
          return 1;
     else if ( n == 1 )
           return base;
     else
          return base * power(base, exp-1);
     int result = base;

}

Now try it. Does it work?

Finalizing the Power Function using Recursion

Unfortunately, this won't work. Whenever you try computing the power of lets say power(2,-3) you will receive 0. Why? Because when you divide and have an int as one of the operands, an int is returned. Below is the fix. If you want to return a double, make sure both your operands are doubles.

int power(int base, int exp) {

      if ( n < - 1)
          return (1.0/base) * power(base, exp+1);
     //Return (1.0/base) when n == -1
     else if ( n == -1 )
          return (1.0/base);
     //Return 1 when n is 0
     else if ( n == 0 )
          return 1;
     else if ( n == 1 )
           return base;
     else
          return base * power(base, exp-1);
     int result = base;

}

By this time you should be able to work out similar problems involving recursion. Make sure you are truly grasping the subject. If not, feel free to ask questions.

C++ Recursion – Power

Diego — Mon, 08 Feb 2010 03:41:54 +0000

Creating a power function using Recursion

Below is an example of how to calculate the x to the power of n. This tutorial expects you to understand the following:

Example:

1 2	pow(2,3); pow(5,4);

Result:

1
2

8
625

Iterative version of a function that calculates the power function

To understand how to calculate the power function using recursion, let’s write a simple algorithm that will do it for us using iteration.

int power(int base, int exp) {
 
     if ( exp == 0 ) {
          return 1; 
     }
 
     //Initial value for the result is the base
     int result = base;
 
     //Multiplies the base by itself exp number of times
     for ( int i = 1; i < exp; i++ ) { 
          result = result * base; 
     }
 
     return result;
}

Calculating the power function using recursion

So how would we go by solving this using recursion? First of all we need a function header.

1	int power(int base, int exp)

Next, what would be our base case? When we are trying to calculate n to the power of 0, the result should be 1. Also, when we try calculating n to the power of 1, the result should be n.

int power(int base, int exp) {
 
     //Return 1 when n is 0
     if ( n == 0 ) return 1;
     else if ( n == 1 ) return base;
}

Now, how would we go on by computing the power function using recursion? Let’s come up with a formula by calculating the following.

power(2,0) = 1;
 
power(2,1) = 2;
 
power(2,2) = 2 * power(2,1) = 2 * 2 = 4;
 
power(2,3) = 2 * power(2,2) = 2 * 4 = 8;
 
power(2,4) = 2 * power(2,3) 2 * 8 = 16;
 
...
 
power(base, exp) = base * power(base, exp-1);

Translating the above formula to code, is then fairly trivial. This would allow us to apply our power function to any two positive integers.

int power(int base, int exp) {
 
     //Return 1 when n is 0
     if ( exp == 0 ) 
          return 1;
     else if ( exp == 1 ) 
           return base;
     else 
          return base * power(base, exp-1);
     int result = base;
 
}

Have any questions? Feel free to ask below or request any other examples.

Going further

1. How would you make this function take care of negative exponents?

C++ Recursion – Factorial

Diego — Tue, 26 Jan 2010 07:06:33 +0000

Creating a factorial function

Below is an example of how to calculate the factorial of n. This tutorial expects you to understand the following:

Example:

1	factorial(5);

Result:

Iterative version of a function that calculates the factorial

To understand how to calculate the factorial using recursion, let’s write a simple algorithm that will do it for us using iteration.

int factorial(int n) {
 
     //Initial value for the final value is 1
     int factorial = 1;
 
     for ( int i = 2; i <= n; i++ ) { 
          factorial = factorial * n;
     }
 
     return factorial;
}

Calculating factorial using recursion

So how would we go by solving this using recursion? First of all we need a function header.

1	int factorial(int n)

Next, what would be our base case? When we are trying to calculate the factorial for 0, the result should be 1.

int factorial(int n) {
 
     //Return 1 when n is 0
     if ( n == 0 ) return 1;
}

Now, how would we go on by computing the factorial using recursion? Let’s come up with a formula by calculating the factorial of 2,3, and 4.

factorial(1) = 1;
 
factorial(2) = 2 * factorial (1) = 2 * 1 = 2;
 
factorial(3) = 3 * factorial (2) = 3 * 2 = 6;
 
factorial(4) = 4 * factorial (3) = 4 * 6 = 24; 
 
...
 
factorial(n) = n * factorial(n-1);

Translating the above formula to code, is then fairly trivial. This would allow us to apply our factorial formula to any positive integer.

int factorial(int n) {
 
     //Return 1 when n is 0
     if ( n == 0 ) return 1;
 
     //factorial(n) = n * factorial(n-1);
     return n * factorial(n-1);
}

Have any questions? Feel free to ask below or request any other examples.