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.

1
2
3
4
5
6

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).

1
2
3
4
5
6
7
8
9
10
11

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.

1
2
3
4
5
6
7
8
9
10
11

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

Related Posts

• C++ Recursion – Palindrome (0)
• Tail Recursion (0)
• Introduction to Recursion in C++ (6)
• C++ Recursion – Logarithm (0)
• C++ Recursion – Greatest Common Divisor (0)
• C++ Recursion – Power Continued (0)
• C++ Recursion – Power (1)
• C++ Recursion Examples (0)
• C++ Recursion – Binary Search (0)
• C++ Recursion – Reverse elements of a vector (0)

Binary search is a method to search through a sorted container in order to find a particular value.

Remember that “Guess the number” game? Let’s look at the following scenario by applying the Binary Search Algorithm in order for you to understand how Binary Search works.

The Guessing Game

Pick a number from 0 – 100 and depending on your guess, I’ll either say Correct, Higher, or Lower. What would you choose?

0

1

…

49

50

51

…

99

100

Well, 50 of course! Why? Best case you get it correct. Worst case you’ll either get a “Higher” or “Lower”. Now think about the following, if you got “Higher” you eliminated 0-49, or 51-100 if “Lower”, in other words, you eliminate HALF the possibilities.

50

51

…

74

75

76

…

99

100

Well, let’s say it was “Higher”. What would you guess after? 75. Since it’s in between 50 – 100. If you didn’t guess correctly, you’ll be facing the similar scenario as before. You’ll end up eliminating half the possibilities!

Getting started on the Binary Search Algorithm

Let’s break up the rules for the Binary Search Algorithm.

• If the number guessed is correct, return the location of the element
• If the number is at a “Higher” location, eliminate the lower half, else eliminate the upper half

Given this information, what would we need for our function header?

Header for Binary Search

We’d need the container and values indicating where our lower and higher boundary are. We’ll be returning the location of the value, else -1 if not found. We’ll also need the key we are looking for.

int binarySearch(vector  vec, int low, int high, int key) {

Next, what would our base cases be? When the element we “pick” is correct, or we exhausted searching through our container.

Base Case for Binary Search

Like mentioned before, the first element to be compared to in our container would be the middle element. We’d also check to see if we exhausted our search by the following base case.

int binarySearch(vector  vec, int low, int high, int key) {

    // We exhausted our search
    if ( low > high ) {
         return -1;
    } 

    // The middle element
    int mid = (low + high)/2;

    if ( vec[mid] == key ) {
        return mid;
    }

If you don’t understand why we have our initial base case, follow along. You’ll understand shortly.

Next, how would we break down our Binary Search on the next recursive call? Well, by simply assigning a new low, or high depending if they key was higher or lower than the one compared to.

Binary Search using Recursion

int binarySearch(vector  vec, int low, int high, int key) {

    // We exhausted our search
    if ( low > high ) {
         return -1;
    } 

    // The middle element
    int mid = (low + high)/2;

    if ( vec[mid] == key ) {
        return mid;
    }

    //If middle index value is larger than our key,
    //we search the lower half of the vector
    //else we search the upper half

    else if ( vec[mid] > key ) {
         return binarySearch(vec, low, mid-1, key);
    } else {
         return binarySearch(vec, mid+1, high, key);
    }
}

If you didn’t understand our initial base case, run through this algorithm using our recursive calls on a small vector without the key you are looking for and you’ll realize why our base case works as follows.

Going further

1. Can you make a helper function to make this calling this function cleaner for the user?
2. Would this algorithm work using an unsorted array?

Related Posts

• C++ Recursion (0)
• C++ Recursion – Logarithm (0)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Reverse elements of a vector (0)
• Tail Recursion (0)
• C++ Helper Functions (0)
• C++ Recursion – Greatest Common Divisor (0)
• C++ Recursion – Fibonacci (0)
• C++ Recursion – Printing Elements of a Vector (0)
• C++ Recursion – Power Continued (0)

Below is an example of how to determine the logarithm of a number of base 2 and then of any base. The logarithm of a number using a given base is power to which the base must be raised to result in the number. This tutorial assumes you understand C++ Recursion and the C++ Recursion – Power function.

Example of finding the logarithm given a base

You could find the base using two different methods.

1. Multiply the base by itself until you receive the number.
2. Divide the number by the base, and repeat until you result in 1. For this method the result is the number of computations to get to 1.

logBase2(8) = 3
2 * 2 * 2 = 8

Method 2:
8/2 = 4
4/2 = 2
2/2 = 1

logBaseN(16,2) = 4
2 * 2 * 2 * 2 = 16

Method 2:
16/2 = 8
8/2 = 4
4/2 = 2
2/2 = 1

Recursive version of logBase2 function

Given the example above, could you come up with a logBase2 recursive function? Let’s try using the 2nd method described above. So what would be our base case and header?

Header and base case for logBase2 function

Below is the header for the logBase2 function. We only need one parameter.

int logBase2(int num) { 

What about our base case? By using our second method we want to stop dividing our number by our base 2 until we result in 1.

int logBase2(int num) { 

      if ( num == 1 )
           return 0; 

LogBase2 Recursive Function

Looking back at our second method, we count the number of computations until our number is 1. Let’s do this. We also break down the problem by diving our number by 2 at each iteration.

int logBase2(int num) { 

      if ( num == 1 )
           return 0; 

      return 1 + logBase2(num/2);

}

Yes, that’s it. This recursive function will return the number which is the power to the base to get to our number.

Recursive version of logBaseN function

Our previous function took care of logBase2 values. What about logBaseN values? This simply means you pass in the base as well. This addition should be trivial.

LogBase2 Recursive Function

Now, we are simply modifying our previous function but this time around we are also passing in the base.

int logBaseN(int num, int base) { 

      if ( num == 1 )
           return 0; 

      return 1 + logBase2(num/base, base);

}

Going further

1. 1. Can you take care of error detection? What if a user puts in erroneous numbers or bases?

Related Posts

• C++ Recursion (0)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Power Continued (0)
• C++ Recursion – Power (1)
• Tail Recursion (0)
• C++ Recursion – Binary Search (0)
• C++ Recursion – Greatest Common Divisor (0)
• C++ Helper Functions (0)
• Introduction to Recursion in C++ (6)
• C++ Variables and Data Types (0)

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.

1. Compare the first and last character
2. 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.

1. If the first and last character don’t match, the word is not a palindrome
2. 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

1. Can you apply this using a vector?

Related Posts

• C++ Recursion (0)
• C++ Recursion – Greatest Common Divisor (0)
• C++ Recursion – Power Continued (0)
• C++ Recursion – Power (1)
• Tail Recursion (0)
• C++ Recursion – Logarithm (0)
• C++ Recursion – Reverse elements of a vector (0)
• C++ Recursion – Fibonacci (0)
• C++ Recursion – Factorial (0)
• C++ Recursion – Summation (2)

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

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

Related Posts

• C++ Recursion – Fibonacci (0)
• C++ Recursion – Power Continued (0)
• C++ Recursion – Power (1)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Factorial (0)
• C++ Recursion – Summation (2)
• Introduction to Recursion in C++ (6)
• Fibonacci in C++ (3)
• C++ Recursion (0)
• C++ Recursion – Binary Search (0)

• 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.

Iterative version of Fibonacci

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.

1
2
3
4
5
6
7
8
9
10
11
12
13

// 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 //
 
   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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 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

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.

1
2
3
4
5
6
7

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.

1
2
3
4
5
6
7
8
9
10
11

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

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

Overview of Fibonacci Sequence using Recursion

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

Related Posts

• C++ Recursion – Reverse elements of a vector (0)
• C++ Recursion – Power Continued (0)
• C++ Recursion – Power (1)
• Fibonacci in C++ (3)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Factorial (0)
• C++ Recursion – Summation (2)
• Introduction to Recursion in C++ (6)
• C++ Recursion (0)
• C++ Recursion – Greatest Common Divisor (0)

Overview of Tail Recursion

Tail Recursion is simply a special form of recursion, in which the recursive call is at the end of the function. This allows for improved efficiency as the final value to be computed is returned without any further calculation when the recursion function terminates.

Factorial without Tail Recursion in C++

First a version without tail recursion will be shown in C++. This version requires that the function has to compute a new value to return to it’s caller after the function it called returned a value.

int fact(int n) {
     if ( n <= 1 ) return n;

     return n  * fact(n-1);
}

Factorial with Tail Recursion in C++

Below is the factorial function with tail recursion. Can you tell the difference from the one posted above? The function below doesn't need to do any more computations when the function it called returns (considering its not the last function that was called). It simply returns the value without any further calculation.

Usually, if it can be done using tail recursion, the function can be iteratively solved as well.

int fact(int n) {
     return fact_h(n, 1);
}

int fact_h(int n, int res) {
   if ( n <= 1 ) return res;

   return fact_h(n-1, n*res);
}

Tail Recursion in a functional language

In C++, if you can write a tail recursive function most likely you can right an iterative version. In a functional language where iteration isn't possible, tail recursion allows for greater efficiency in such functions.

Recursive function in ML without tail recursion

Below is a factorial function in ML. This version does not implement tail recursion.

fun fact 1  = 1 
| fact x = x * fact (x-1);

Implementing Tail Recursion in ML

The function below, does implement tail recursion. If you notice, this function does not require to do any computations after the function has returned as the function in the previous version.

fun facth 1 n = n
| facth x n = facth (x-1) (n*x);
 
fun fact 1 = 1
| fact x = facth x 1;

Overview of Tail Recursion

So why is this faster? Well, first of all, it means you are uses the stack less, thus increasing efficiency. If you can implement tail recursion in a programming language such as C++, there must be an iterative version of the function. On the other hand if you are creating functions in a logic or functional programming language, try using tail recursion. On large projects you'll notice a great improvement in runtime.

Related Posts

• C++ Recursion (0)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Logarithm (0)
• C++ Recursion – Greatest Common Divisor (0)
• C++ Recursion – Power Continued (0)
• C++ Recursion – Power (1)
• C++ Recursion – Factorial (0)
• C++ Helper Functions (0)
• Introduction to Recursion in C++ (6)
• C++ Recursion Examples (0)

A helper function is merely a function that passes additional arguments to another function of a similar name. The additional arguments that are passed in are usually predetermined by the programmer that allow the use of recursion.

This tutorial considers you are knowledgeable with recursion since our example deals with a recursive function.

Example of a helper function

Below we’ll provide you an example of when you might encounter the use of a helper function. We’ll start off by introducing a simple print function that prints all the elements of a vector.

void print(vector  vec) { 

     for ( int i = 0; i < vec.size(); i++ ) {
          cout << i << ": " << vec[i] << endl;
     }
}

This function would be called in your main program in the following way.

#include 
#include 

using namespace std;

int main() { 

     vector  vec;

     /* Fill the vector with values...using push_back() perhaps? */

     //Calling of our function
     print(vec);

     return 0;
}

Where the helper function comes in

Now, imagine for some reason you want to try making your print function recursively. The thing is, if you want to print using recursion, you need your function to have an additional parameter in order to track what element we are currently printing.

This would mean that we would have to change all our calls to our print function to include an additional parameter. Well, we don't if we use a helper function. By simply having our original print function call our helper function, we avoid changing the names of all our calls.

void print(vector  vec) { 

     print_h(vec, 0);

}

void print_h(vector  vec, int i) { 

    if ( i > vec.size() ) {
        return;
    }

    cout << i << ": " << vec[i] << endl;

    print(vec, i+1);

    return;
}

Related Posts

• Tail Recursion (0)
• C++ Recursion (0)
• C++ Recursion – Binary Search (0)
• C++ Recursion – Logarithm (0)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Reverse elements of a vector (0)
• C++ Recursion – Printing Elements of a Vector (0)
• Introduction to Recursion in C++ (6)
• Introduction to Functions (0)
• Simple Data Structure – The Vector (4)

• It’s easier to solve certain problems with recursion as the resulting code is usually shorter
• Sometimes its the only way

Displaying numbers recursively

So what’s an example of a recursive function? Let’s make one. Let’s start by creating a function that displays a number (it isn’t the best example, but it’s good enough to introduce you to recursion).

Display Function

1
2
3
4
5

void display(int n) 
{
     cout << n << " ";
     return;
}

All this function does is simply print the number passed in.

Recursive Display Function

Now let’s have this function call itself but lets decrement the value being displayed each time.

1
2
3
4
5
6

void display(int n)
{
     cout << n << " ";
     display(n-1); //Will call display but with (n-1)
     return;
}

So let’s say we executed display(10)

What would this display? It would display 10 9 8 7 6 5 4…and would never stop. Why? We never told the function when to terminate. This will either cause your program to run until you kill it, or may cause it to segmentation fault. In order to fix this, this calls for the addition of base case.

Base Cases in Recursion

In order for your recursive function to terminate you always need a base case. You may have multiple base cases.

Recursive Display Function with a Base Case

Let’s make the function terminate when n is 0. Or better yet, let’s make it terminate when n is less than or equal to 0. (Why do you think this is better?)

1
2
3
4
5
6
7

void display(int n)
{
     if ( n <= 0 ) return; 
     cout << n << " ";
     display(n-1); //Will call display but with (n-1)
     return;
}

So now, if we execute display(10), what would it display?

10 9 8 7 6 5 4 3 2 1 

How Recursion works in C++

So how does recursion work in C++? Each function creates an activation record on the stack. As a function gets called, it gets added to the top of the stack. Until the function is terminated, is then taken off the stack. A visual example for our display function is below.

(Click to Enlarge)

The first function called was display(10) which is the activation record seen at the bottom of our stack. If you notice, the following function keep getting called as long as the base case isn’t met. Up until n = -1, then the activation record of the functions are popped off.

Comments on Recursion

What is shown previously is a very basic recursive algorithm. More recursion techniques will be discussed later. So even if you don’t understand the purpose of recursion just yet, don’t hesitate. You’ll understand why it’s important when you understand recursion is the only way to do certain problems.

Related Posts

• C++ Recursion (0)
• C++ Recursion – Palindrome (0)
• C++ Recursion – Reverse elements of a vector (0)
• C++ Recursion – Fibonacci (0)
• C++ Recursion – Printing Elements of a Vector (0)
• C++ Recursion – Factorial (0)
• C++ Recursion – Summation (2)
• Tail Recursion (0)
• Fibonacci in C++ (3)
• C++ Recursion Examples (0)