Different Methods to Reverse a String in C++ (original) (raw)

Last Updated : 23 Apr, 2025

Try it on GfG Practice redirect icon

Reversing the string means the last character will be the first character, second last character will be second character and so on. In C++, we can reverse a string in various different ways as show below:

Table of Content

Using reverse() Function

C++ STL provides a built-in function **reverse(), which can be used to reverse the string efficiently.

**Example

C++ `

#include <bits/stdc++.h> using namespace std;

int main() { string s = "Hello World";

// Using reverse() function to reverse s
reverse(s.begin(), s.end());

cout << s;
return 0;

}

`

**Time Complexity: O(n), where **n is the length of string.
**Auxiliary Space: O(1)

Using Reverse Iterators

In C++, reverse iterators such as string.rbegin() and string.rend() are used to allow the traversal of string in reverse. We can use them to construct temporary reversed version of the string and then assign it to the original string.

**Example

C++ `

#include <bits/stdc++.h> using namespace std;

int main() { string s = "Hello World";

// Creating a temporary reversed string
  // and assigning it to the s
s = string(s.rbegin(), s.rend());

  cout << s;
return 0;

}

`

**Time Complexity: O(n), where **n is the length of string.
**Auxiliary Space: O(n), for temporary reversed string.

Using a Stack

A stack can also be used to reverse a string due to its LIFO (Last In First Out) property. We can push all characters of the string into a stack and clear the current string. Then we pop characters from the stack and append them to the string one by one, resulting in the reversed string.

**Example

C++ `

#include <bits/stdc++.h> using namespace std;

int main() { string s = "Hello World"; stack st;

// Push each character of string into stack
for (char c : s)
    st.push(c);

// Clear the string
s.clear();

// Pop characters from stack and add them to
// reversed string
while (!st.empty()) {
    s.push_back(st.top());
    st.pop();
}

cout << s;
return 0;

}

`

**Time Complexity: O(n), where **n is the length of string.
**Auxiliary Space: O(n), for stack.

Using Two Pointer Technique

In two-pointer technique, we use two pointers: one starting at the beginning (left) and one at the end (right) of the string. We move them towards the centre of the string and keep swapping the characters they point till they meet each other.

**Example

C++ `

#include <bits/stdc++.h> using namespace std;

int main() { string s = "Hello World";

// Initialize two pointers: left at start
//  and right at the end of the string
int l = 0;
int r = s.length() - 1;

// Loop until the two pointers meet in the middle
while (l < r) {
  
    // Swap characters at position left and right
    swap(s[l], s[r]);

    // Move the left pointer to right
    l++;

    // Move the right pointer to left
    r--;
}

cout << s;
return 0;

}

`

**Time Complexity: O(n), where **n is the length of string.
**Auxiliary Space: O(1)

**Note: Two pointer technique is implemented in the std::reverse() function.

Using Recursion

The two-pointer technique can also be implemented using recursion though it can be less space efficient and harder to understand.

**Example

C++ `

#include <bits/stdc++.h> using namespace std;

// Function to reverse the string using recursion void revStr(string &s, int l, int r) {

// Base case: When left and right pointer meet
if (l >= r)
    return;

// Swap characters at left and right
swap(s[l], s[r]);

// Recursive call to reverse remaining substring
revStr(s, l + 1, r - 1);

}

int main() { string s = "Hello World";

// Call the recursive function to reverse string
revStr(s, 0, s.length() - 1);

cout << s;
return 0;

}

`

**Time Complexity: O(n), where **n is the length of string.
**Auxiliary Space: O(n), for recursive stack.