Strings in C++: Recursion in Strings

This chapter explores how to apply recursive patterns to string manipulation problems in C++. We will transition from iterative two-pointer approaches to elegant recursive designs, analyze memory layouts, and address critical C++ execution pitfalls such as call-by-value versus call-by-reference.

1. Introduction to String Recursion & The Palindrome Problem

A palindrome is a sequence of characters that reads the same forward and backward. When evaluating strings recursively, we treat the string as a collection of characters indexed from 0 to N-1.

Real-World Examples

• "naman" $\rightarrow$ Reads "naman" from left-to-right and right-to-left. (Result: 1 / true)
• "mom" $\rightarrow$ Reads "mom" from both directions. (Result: 1 / true)
• "rohit" $\rightarrow$ Reads "tihor" from right-to-left. (Result: 0 / false)

To determine if a string is a palindrome, we must compare characters from both ends and move inward.

2. The Two-Pointer Mental Model (Iterative vs. Recursive)

In a standard iterative approach, we use two pointers: start at index 0 and end at index N-1.

Index:    0    1    2    3    4
String:   n    a    m    a    n
          ^                   ^
          |                   |
        start                end

Iterative Workflow

1. Compare str[start] and str[end].
2. If they match, increment start (start++) and decrement end (end--).
3. If they do not match, immediately terminate and declare the string a non-palindrome.
4. Stop when start >= end.

Transitioning to Recursion

Recursion mimics this two-pointer approach by passing start and end as arguments in the function signature. Instead of using a loop, the function processes the current pointers and delegates the remaining substring to a recursive call.

3. Step-by-Step Evolution of the Recursive Palindrome Algorithm

To design the recursive function, we must define three core components:

A. The Base Case

We stop comparing when the pointers cross or meet. At this point, all previous character pairs have matched successfully.

if (start >= end) {
    return true; // Or return 1
}

B. The Mismatch Condition

If the characters at the current start and end indices do not match, we can immediately stop and return false.

if (str[start] != str[end]) {
    return false; // Or return 0
}

C. The Recursive Step

If the current characters match, we delegate the decision to the remaining inner substring by incrementing start and decrementing end.

return checkPalindrome(str, start + 1, end - 1);

4. Palindrome Recursion Tree Walkthrough

Let us trace the execution flow of our recursive algorithm using two different test cases.

Case 1: Successful Match ("naman")

The function is called with start = 0 and end = 4.

The return value 1 bubbles back up through the call stack:

Case 2: Mismatch ("namon")

The function is called with start = 0 and end = 4.

The return value 0 bubbles back up, skipping any further comparisons.

5. C++ Implementation & The "Forgotten Return" Debugging Pitfall

Below is the complete C++ implementation for checking palindromes.

#include <iostream>
#include <string>

using namespace std;

// Recursive function to check if a string is a palindrome
bool checkPalindrome(string str, int start, int end) {
    // Base Case: If pointers cross, all characters matched
    if (start >= end) {
        return true;
    }

    // If characters at start and end do not match
    if (str[start] != str[end]) {
        return false;
    }

    // Recursive Step: Check the inner substring
    // CRITICAL: You must write 'return' here to pass the result back up the stack!
    return checkPalindrome(str, start + 1, end - 1);
}

int main() {
    string str = "naman";
    
    // Pass string, start index (0), and end index (length - 1)
    bool isPalindrome = checkPalindrome(str, 0, str.length() - 1);
    
    cout << "Is Palindrome: " << isPalindrome << endl; // Outputs 1 (true)
    
    string str2 = "rohit";
    cout << "Is Palindrome: " << checkPalindrome(str2, 0, str2.length() - 1) << endl; // Outputs 0 (false)
    
    return 0;
}

Warning: The "Forgotten Return" Pitfall During development, a common mistake is omitting the return keyword in the recursive call:

C++

Copy

// INCORRECT
checkPalindrome(str, start + 1, end - 1); 

Without the return statement, the function computes the correct value at the base case but fails to pass it back up the call stack. This leads to undefined behavior or default return values (often returning 0 or garbage values). Always ensure your recursive steps return their evaluations.

6. Problem 2: Counting Vowels in a String

Our next problem is to count the total number of vowels ('a', 'e', 'i', 'o', 'u') in a given lowercase string.

Example

• Input: "rohit"
• Vowels: 'o', 'i'
• Output: 2

7. Optimizing Parameters: Why Processing Backwards is Superior

When designing a recursive function to traverse a string, we can move from left-to-right (index 0 to N-1) or right-to-left (index N-1 to 0).

Why Backward Traversal is Cleaner in Recursion

If we traverse forward, our base case depends on the dynamic length of the string, which requires passing an extra length parameter or calling str.length() repeatedly.

By starting at the last index ($N-1$) and decrementing down to -1, our base case stops at a constant value (-1). This allows us to write a cleaner function signature with only two arguments:

int countVowels(string str, int index);

Mathematical Formulation

For any character at index:

8. C++ Implementation for Counting Vowels

Here is the complete recursive implementation for counting vowels, traversing from the end of the string to the beginning.

#include <iostream>
#include <string>

using namespace std;

// Helper function to check if a character is a vowel
bool isVowel(char ch) {
    return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u');
}

// Recursive function to count vowels from right to left
int countVowels(string str, int index) {
    // Base Case: If we have moved past the first character (index 0)
    if (index == -1) {
        return 0;
    }

    // Check if current character is a vowel
    if (isVowel(str[index])) {
        // Return 1 (for current vowel) + count of vowels in the remaining substring
        return 1 + countVowels(str, index - 1);
    } else {
        // Return 0 (not a vowel) + count of vowels in the remaining substring
        return countVowels(str, index - 1);
    }
}

int main() {
    string str = "rohit";
    // Start processing from the last index (length - 1)
    int totalVowels = countVowels(str, str.length() - 1);
    
    cout << "Total Vowels: " << totalVowels << endl; // Outputs 2
    return 0;
}

9. Problem 3: Reversing a String In-Place

Reversing a string involves swapping characters from the outer edges and moving inward. We want to perform this operation in-place to avoid allocating extra memory for a new string.

Initial:    r   o   h   i   t
            ^               ^
            |               |
          start            end

Swap 1:     t   o   h   i   r
                ^       ^
                |       |
              start    end

Swap 2:     t   i   h   o   r
                    ^
                    |
                start/end (Stop)

10. The Critical C++ Pitfall: Call-by-Value vs. Call-by-Reference

When passing a string to a function in C++, the default behavior is call-by-value. This creates a copy of the string in memory for the function's execution frame.

The Call-by-Value Failure Mode

If we pass the string by value, the swaps occur on the local copy inside the recursive function. The original string in the main function remains unchanged.

The Call-by-Reference Solution

To modify the original string, we must pass it by reference using the ampersand (&) operator. This passes an alias to the original memory location, ensuring all swaps directly modify the original string.

void reverseString(string &str, int start, int end);

11. C++ Implementation for Reversing a String

Below is the recursive implementation for reversing a string in-place using call-by-reference.

#include <iostream>
#include <string>

using namespace std;

// Recursive function to reverse a string in-place
// Note the use of 'string &str' to pass by reference
void reverseString(string &str, int start, int end) {
    // Base Case: Stop when pointers meet or cross
    if (start >= end) {
        return;
    }

    // Swap characters at start and end indices
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;

    // Recursive Step: Move inward
    reverseString(str, start + 1, end - 1);
}

int main() {
    string str = "rohit";
    
    // Reverse the string in-place
    reverseString(str, 0, str.length() - 1);
    
    cout << "Reversed String: " << str << endl; // Outputs "tihor"
    return 0;
}

12. Problem 4: Lowercase to Uppercase Conversion via ASCII Math

To convert a lowercase character to uppercase, we can use ASCII offsets.

The Math Behind ASCII Conversion

The distance between any lowercase letter and its uppercase counterpart is constant in the ASCII table.

• ASCII value of 'a' = 97
• ASCII value of 'A' = 65
• Difference: 'a' - 'A' = 32

To convert a lowercase character ch to uppercase:

Example Walkthrough for 'r'

1. 'r' - 'a' $\rightarrow$ $114 - 97 = 17$ (This means 'r' is the 17th character after 'a').
2. 'A' + 17 $\rightarrow$ $65 + 17 = 82$.
3. ASCII value 82 corresponds to the character 'R'.

13. C++ Implementation for Case Conversion & Homework Challenge

Here is the recursive implementation to convert a lowercase string to uppercase in-place.

#include <iostream>
#include <string>

using namespace std;

// Recursive function to convert lowercase to uppercase in-place
void lowerToUpper(string &str, int index) {
    // Base Case: Stop when we have processed all characters
    if (index == -1) {
        return;
    }

    // Convert current character to uppercase using ASCII math
    str[index] = 'A' + (str[index] - 'a');

    // Recursive Step: Process the remaining characters to the left
    lowerToUpper(str, index - 1);
}

int main() {
    string str = "rohitnegi";
    
    // Start converting from the last index
    lowerToUpper(str, str.length() - 1);
    
    cout << "Uppercase String: " << str << endl; // Outputs "ROHITNEGI"
    return 0;
}

Homework Challenge: Uppercase to Lowercase

To convert an uppercase string to lowercase, reverse the ASCII math logic:

14. Summary of String Recursion Patterns

The table below summarizes the recursive strategies, base cases, and key concepts covered in this chapter.

15. Summary and Key Takeaways

• Two-Pointer Recursion: Problems that compare or swap characters from both ends of a string (like palindromes and reversals) are best solved recursively by passing start and end pointers as arguments.
• The Importance of return in Recursive Chains: When a recursive function returns a value (such as a bool or int), you must prepend the recursive call with the return keyword to pass the result back up the call stack.
• Optimizing Signatures with Backward Traversal: Processing strings from right-to-left (starting at N-1 and ending at -1) simplifies your base cases to a constant value, reducing the number of arguments needed in your function signature.
• Call-by-Value vs. Call-by-Reference: By default, C++ passes strings by value, which copies the string and discards any modifications. To perform in-place operations like reversing or case conversion, you must pass the string by reference using string &str.
• In-Place Memory Efficiency: Modifying strings in-place using references keeps your space complexity at $O(d)$ (where $d$ is the recursion stack depth) and avoids the $O(N)$ space overhead of allocating new strings.
• ASCII Math for Case Conversion: You can easily convert character cases without library functions by calculating their offset from base characters like 'a' or 'A'.