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?

• 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
14
15

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

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.

1. C++ Recursion
2. C++ Recursion – Summation

Example:

1

factorial(5);

Result:

1

120

Iterative version of a function that calculates the factorial

1
2
3
4
5
6
7
8
9
10
11

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

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.

1
2
3
4
5

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.

1
2
3
4
5
6
7
8
9
10
11

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.

1
2
3
4
5
6
7
8

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.

Example:

1

sum(10);

Result:

1

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55

Iterative version of a function that calculates the summation

1
2
3
4
5
6
7
8
9
10

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

Calculating the summation using recursion

1

int sum(int n)

Next, if you remember from the basics of recursion, our function needs a base case or terminating condition. What would it be in this case? When we are trying to sum the sequence consisting of only 0. We also don’t want to calculate the summation of negative numbers.

1
2
3
4
5

int sum(int n) { 
 
     //Return 0 when n is 0
     if ( n <= 0 ) return 0;
}

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

1
2
3
4
5
6
7
8
9
10
11

summation(0) = 0;
 
summation(1) = 1 + summation(0) = 1 + 0 = 1;
 
summation(2) = 2 + summation(1) = 2 + 1 = 3;
 
summation(3) = 3 + summation(2) = 3 + 3 = 6; 
 
...
 
summation(n) = n * summation(n-1);

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

1
2
3
4
5
6
7
8

int sum(int n) { 
 
     //Return 0 when n is 0
     if ( n <= 0 ) return 0;
     else 
          return n + sum(n-1);
 
}

The previous recursive function will work as follows (in our case, sum(3)).

]

Have any questions? Feel free to ask below.

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

The Fibonacci Numbers Sequence

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

The formula for Fibonacci

Computing for Fibonacci is simple. The formula is below.

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

To computer for Fibonacci of 7, simply add the values of Fibonacci of 6 and Fibonacci of 5. In other words, the sum of the previous two values.

Fibonacci(7) = Fibonacci(6) + Fibonacci(5);
Fibonacci(7) = 8 + 5;
Fibonacci(7) = 13;

Iterative version of Fibonacci

This is an iterative version of Fibonacci.

int fib(int n) {
    if ( n == 0 || n == 1 ) 
        return n;
 
    int fib1 = 0; 
    int fib2 = 1;
    int fib = 0;
 
    for ( int i = 2; i < n; i++ ) 
    {
        fib = fib1 + fib2;
        fib1 = fib2;
        fib2 = fib;
    }
 
    return fib;
}

Recursive version of Fibononacci

The recursive version of Fibonacci in C++ is below. This recursive function computes the sum of the previous two fibonacci numbers recursively.

int fib(int n)
{
     if ( n == 0 ) return 0;
     if ( n == 1 ) return 1;
 
     return fib(n-1) + fib(n-2);
}

An image of how this recursive solution works is below. Each bubble is a function call.

Dynamic Programming version of Fibonacci

The dynamic programming version of Fibonacci in C++ is below. This snippet of code computes the fibonacci by traversing a vector.

 
vector <int> fib;
fib.push_back(0);
fib.push_back(1);
 
int n; //N is the number of fibonacci numbers we are going to compute. 
 
for ( int i = 2; i < n; i++ ) 
{
      fib.push_back( fib[i-1] + fib[i-2] );
}

Finishing remarks

So, which one do you think is the fastest version?