Reverse a String

This one looks easy. Just flip the string, right? But the interviewer is not asking because it is hard. They want to see how you think. Do you reach for a built-in function and stop there? Or can you show the logic underneath? That is the real test here. They want to know if you understand in-place reversal and the two-pointer trick.

🔄 The Problem

You are given a string. A string is just a sequence of characters, like the letters in a word. You have to return it with the characters in reverse order. If you can, do it in place. In place means you change the same memory. You do not create a brand new string just to hold the answer.

Input:  "hello"
Output: "olleh"

Input:  "FreeCodingSchool"
Output: "loohcSgnidoCeerF"

🐢 The Simple Approach First

The first idea most people have is simple. Make a new empty string. Then walk through the original from the last character to the first. Add each one to the new string. At the end you have the reversed version.

It works. But there is a catch. You are building a whole new string in memory. So you use extra space equal to the size of the input. In an interview that is fine as a first answer. But they will almost always ask, “can you do it without the extra string?” That is your signal to talk about the better way.

🎯 The Optimal Approach: Two Pointers

Here is the trick the interviewer wants to hear. Put one pointer at the start of the string and one at the end. A pointer here just means a variable holding an index, a position in the string. Now swap the two characters at those positions. Then move the left pointer one step right and the right pointer one step left. Keep going until they meet in the middle.

Think of it like a row of students sitting on a bench. The first student and the last student stand up and switch seats. Then the second and second-to-last switch. You keep going inward. When you reach the middle, everyone has swapped and the row is reversed. No new bench needed. You reused the same one.

One thing to remember. In Java, Python, and JavaScript a string cannot be changed once it is made. We say it is immutable, which means its value is fixed and you cannot edit a single character inside it. So in those languages we first turn the string into a character array or list. We swap inside that. Then we join it back into a string at the end.

Steps to reverse the string

1. Set left to the first index and right to the last index.
2. While left is less than right, swap the characters at left and right.
3. Move left one step forward and right one step backward.
4. Stop when the two pointers meet or cross. The string is now reversed.

#include <stdio.h>
#include <string.h>

// Reverse the string in place using two pointers.
void reverseString(char str[]) {
    int left = 0;
    int right = (int)strlen(str) - 1;
    while (left < right) {
        // Swap the characters at the two ends.
        char temp = str[left];
        str[left] = str[right];
        str[right] = temp;
        left++;
        right--;
    }
}

int main() {
    char str[] = "hello";
    reverseString(str);
    printf("%s\n", str);
    return 0;
}

olleh

#include <iostream>
#include <string>
using namespace std;

// Reverse the string in place using two pointers.
void reverseString(string &str) {
    int left = 0;
    int right = (int)str.size() - 1;
    while (left < right) {
        // Swap the characters at the two ends.
        swap(str[left], str[right]);
        left++;
        right--;
    }
}

int main() {
    string str = "hello";
    reverseString(str);
    cout << str << endl;
    return 0;
}

olleh

public class ReverseString {
    // Strings are immutable, so we work on a char array.
    static String reverseString(String s) {
        char[] chars = s.toCharArray();
        int left = 0;
        int right = chars.length - 1;
        while (left < right) {
            // Swap the characters at the two ends.
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        return new String(chars);
    }

    public static void main(String[] args) {
        System.out.println(reverseString("hello"));
    }
}

olleh

# Strings are immutable, so we work on a list of characters.
def reverse_string(s):
    chars = list(s)
    left = 0
    right = len(chars) - 1
    while left < right:
        # Swap the characters at the two ends.
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1
    return "".join(chars)


print(reverse_string("hello"))

olleh

// Strings are immutable, so we work on an array of characters.
function reverseString(s) {
  const chars = s.split("");
  let left = 0;
  let right = chars.length - 1;
  while (left < right) {
    // Swap the characters at the two ends.
    const temp = chars[left];
    chars[left] = chars[right];
    chars[right] = temp;
    left++;
    right--;
  }
  return chars.join("");
}

console.log(reverseString("hello"));

olleh

⏱️ Time and Space Complexity

The two-pointer way touches each character once. So it is O(n) time. In C and C++ we swap inside the same string, so there is no real extra space. That is O(1). In Java, Python, and JavaScript we need a char array copy first, so that copy counts as O(n) space.

🧩 Key Takeaways

• ✅ Use two pointers, one at each end, and swap your way inward until they meet.
• ✅ The two-pointer scan is O(n) time, and it is O(1) extra space when the language lets you edit the string in place.
• ✅ In Java, Python, and JavaScript strings are immutable, so convert to a char array or list first, then join back at the end.
• ✅ Know the built-in shortcuts, but show the manual logic in the interview.

🚀 What’s Next?

• Check Palindrome String
• Reverse an Array