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

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