C++ Program To Reverse Words In A Given String

Last Updated : 17 Aug, 2023

Example: Let the input string be “i like this program very much”. The function should change the string to “much very program this like i”

reverse-words

Examples:

Input: s = “geeks quiz practice code”
Output: s = “code practice quiz geeks”

Input: s = “getting good at coding needs a lot of practice”
Output: s = “practice of lot a needs coding at good getting”

Algorithm:

Initially, reverse the individual words of the given string one by one, for the above example, after reversing individual words the string should be “i ekil siht margorp yrev hcum”.
Reverse the whole string from start to end to get the desired output “much very program this like i” in the above example.

Below is the implementation of the above approach:

C++

   // C++ program to reverse a string 
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to reverse words 
void reverseWords(string s) 
{     
    // Temporary vector to store all words 
    vector<string> tmp; 
    string str = ""; 
    for (int i = 0; i < s.length(); i++)  
    {         
        // Check if we encounter space  
        // push word(str) to vector 
        // and make str NULL 
        if (s[i] == ' ')  
        { 
            tmp.push_back(str); 
            str = ""; 
        } 
  
        // Else add character to  
        // str to form current word 
        else
            str += s[i]; 
    } 
    
    // Last word remaining,add it to vector 
    tmp.push_back(str); 
  
    // Now print from last to first in vector 
    int i; 
    for (i = tmp.size() - 1; i > 0; i--) 
        cout << tmp[i] << " "; 
    // Last word remaining,print it 
    cout << tmp[0] << endl; 
} 
  
// Driver Code 
int main() 
{ 
    string s =  
    "i like this program very much"; 
    reverseWords(s); 
    return 0; 
}
 
  

Output

much very program this like i

The above code doesn’t handle the cases when the string starts with space. The following version handles this specific case and doesn’t make unnecessary calls to reverse function in the case of multiple spaces in between. Thanks to rka143 for providing this version.

C++

   // C++ program to implement 
// the above approach 
void reverseWords(char* s) 
{ 
  char* word_begin = NULL; 
  
  // temp is for word boundary  
  char* temp = s; 
  
  // STEP 1 of the above algorithm  
  while (*temp)  
  { 
    /*This condition is to make sure that  
      the string start with valid character  
      (not space) only*/
    if ((word_begin == NULL) &&  
        (*temp != ' '))  
    { 
      word_begin = temp; 
    } 
    if (word_begin &&  
       ((*(temp + 1) == ' ') || 
       (*(temp + 1) == '')))  
    { 
      reverse(word_begin, temp); 
      word_begin = NULL; 
    } 
    temp++; 
  
  // End of while  
  }  
  
  // STEP 2 of the above algorithm  
  reverse(s, temp - 1); 
} 
  
// This code is contributed by rutvik_56.
 
  

Time Complexity: O(n)

Another Approach:

we can do the above task by splitting and saving the string in a reverse manner.

Below is the implementation of the above approach:

C++

   // C++ program to reverse a string 
// s = input() 
#include <bits/stdc++.h> 
using namespace std; 
  
// Driver code 
int main() 
{ 
    string s[] = {"i", "like", "this",  
                  "program", "very", "much"}; 
                                          
    string ans = ""; 
    for (int i = 5; i >= 0; i--)  
    { 
        ans += s[i] + " "; 
    } 
    cout <<  
    ("Reversed String:") << endl; 
    cout <<  
    (ans.substr(0, ans.length() - 1)) <<  
     endl; 
  
    return 0; 
} 
// This code is contributed by divyeshrabadiya07. 
 
  

Output

Reversed String:  much very program this like i

Time Complexity: O(n)

Without using any extra space:
The above task can also be accomplished by splitting and directly swapping the string starting from the middle. As direct swapping is involved, less space is consumed too.

Below is the implementation of the above approach:

C++

   // C++ code to reverse a string 
#include <bits/stdc++.h> 
using namespace std; 
  
// Reverse the string 
string RevString(string s[], int l) 
{     
    // Check if number of words is even 
    if (l % 2 == 0) 
    {         
        // Find the middle word 
        int j = l / 2; 
          
        // Starting from the middle 
        // start swapping words at  
        // jth position and l-1-j position 
        while (j <= l - 1) 
        { 
            string temp; 
            temp = s[l - j - 1]; 
            s[l - j - 1] = s[j]; 
            s[j] = temp; 
            j += 1; 
        } 
    } 
      
    // Check if number of words is odd 
    else
    {         
        // Find the middle word 
        int j = (l / 2) + 1; 
          
        // Starting from the middle start 
        // swapping the words at jth  
        // position and l-1-j position 
        while (j <= l - 1)  
        { 
            string temp; 
            temp = s[l - j - 1]; 
            s[l - j - 1] = s[j]; 
            s[j] = temp; 
            j += 1; 
        } 
    } 
      
    string S = s[0]; 
      
    // Return the reversed sentence 
    for(int i = 1; i < 9; i++) 
    { 
        S = S + " " + s[i]; 
    } 
    return S; 
} 
  
// Driver code 
int main() 
{ 
    string s = "getting good at coding "
               "needs a lot of practice"; 
                 
    string words[] = {"getting", "good", "at",  
                      "coding", "needs", "a",  
                      "lot", "of", "practice"}; 
       
    cout << RevString(words, 9) << endl; 
    return 0; 
} 
  
// This code is contributed by divyesh072019
 
  

Output

practice of lot a needs coding at good getting

Another intuitive constant space solution: Go through the string and mirror each word in the string, then, at the end, mirror the whole string.

The following C++ code can handle multiple contiguous spaces.

C++

   // C++ program to implement 
// the above approach 
#include <algorithm> 
#include <iostream> 
#include <string> 
 using namespace std; 
   
string reverse_words(string s) 
{ 
    int left = 0, i = 0, n = s.size(); 
     
    while (s[i] == ' ') 
        i++; 
     
    left = i; 
     
    while (i < n) 
    { 
        if (i + 1 == n ||  
            s[i] == ' ') 
        { 
            int j = i - 1; 
            if (i + 1 == n) 
                j++; 
             
            while (left < j) 
                swap(s[left++], s[j--]); 
             
            left = i + 1; 
        } 
        if (s[left] == ' ' && i > left) 
            left = i; 
         
        i++; 
    } 
    reverse(s.begin(), s.end()); 
    return s; 
} 
  
// Driver code 
int main() 
{  
    string str =  
    "Be a game changer the world is already full of players";  
    str = reverse_words(str);  
    cout << str;    
    return 0; 
} 
// This code is contributed by Gatea David 
 
  

Output

players of full already is world the changer game a Be

Reverse Words in a String Using Two-Pointer Approach

Approach:

Reverse the entire string.
Reverse each word in the reversed string.

Steps:

Start by taking the input string as s.
Reverse the entire string s using a two-pointer approach.
Initialize two pointers, start and end, both pointing to the first character of the reversed string.
Traverse the string s and when a space is encountered, reverse the word between start and end pointers using a similar two-pointer approach.
Update the start pointer to the next character after the space and the end pointer to the same position as the start pointer.
Repeat step 4 and 5 until the end of the string is reached.
Return the reversed string.

C++

   #include <iostream> 
#include <string> 
using namespace std; 
  
void reverseWord(string& s, int start, int end) { 
    while (start < end) { 
        swap(s[start], s[end]); 
        start++; 
        end--; 
    } 
} 
  
string reverseString(string s) { 
    int start = 0, end = s.length() - 1; 
    reverseWord(s, start, end); 
  
    start = 0; 
    end = 0; 
    while (end < s.length()) { 
        if (s[end] == ' ') { 
            reverseWord(s, start, end - 1); 
            start = end + 1; 
        } 
        end++; 
    } 
    reverseWord(s, start, end - 1); 
    return s; 
} 
  
int main() { 
    string s = "i am omkhar"; 
    cout << reverseString(s) << endl; 
    return 0; 
} 
 
  

Output

omkhar am i

Time complexity: O(n), where n is the length of the input string.
Auxiliary space: O(1), the algorithm uses constant space to perform the reverse operation in-place.

Please refer complete article on Reverse words in a given string for more details!

How to Reverse a String in Place in C++?

kartik

Improve

Article Tags :

Practice Tags :

C++ Program To Reverse Words In A Given String

C++

C++

C++

C++

C++

Reverse Words in a String Using Two-Pointer Approach

C++

Similar Reads