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?