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

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?

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.

[pmath]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
[/pmath]

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?

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?

• 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

1
2
3
4
5
6
7
8
9
10
11

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

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

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

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

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

Power Function using Recursion

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

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

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.

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

Example:

1
2

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

Result:

1
2

8
625

Iterative version of a function that calculates the power function

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

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

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.

1
2
3
4
5
6

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.

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

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.

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

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?
]]> http://talkbinary.com/programming/c/c-recursion-power/feed/ 4 http://talkbinary.com/programming/c/c-tail-recursion/ http://talkbinary.com/programming/c/c-tail-recursion/#comments Thu, 14 May 2009 18:54:06 +0000 Diego http://talkbinary.com/?p=1647   Full Article… ]]>

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.

]]> http://talkbinary.com/programming/c/c-tail-recursion/feed/ 0