Reverse an Array

This is one of the first array questions you will ever get in an interview. It looks easy. But the interviewer is not really asking you to reverse an array. They want to see if you can do it in place, without making a second array.

🔄 The Problem

Given an array of numbers, reverse it. The first element should become the last, the last should become the first, and so on.

Here is what that looks like:

Input:  [1, 2, 3, 4, 5]
Output: [5, 4, 3, 2, 1]

The catch is the follow-up the interviewer almost always adds: do it in place. In place means you change the same array directly. You do not create a new array to hold the answer. So you are only allowed a tiny bit of extra memory, like one or two variables.

🧠 The Simple Idea First

Before the smart way, let’s think about the obvious way. You could make a new empty array. Then you walk the original from the last element to the first, and push each one into the new array.

That works. But it uses a whole second array. So the extra memory grows with the input. That is O(n) extra space, and the interviewer wanted O(1). So this is the version to mention, then improve.

✌️ The Two Pointer Way

Here is the trick interviewers want. It is called the two pointer technique. You keep two markers:

• One pointer called left starts at the very first index.
• One pointer called right starts at the very last index.

Then you just swap the two values they point at, move left one step right, move right one step left, and repeat. You stop when they meet in the middle.

Think of it like two people standing at opposite ends of a line of boxes. They each grab a box, trade boxes, then step toward each other. By the time they meet, the whole line is reversed.

Steps to reverse an array in place

Let’s write the steps down before any code.

1. Set left = 0 and right = n - 1, where n is the number of elements.
2. While left < right:
   • Swap array[left] and array[right].
   • Do left = left + 1.
   • Do right = right - 1.
3. When left and right cross, the array is fully reversed.

Code to reverse an array in place

Now let’s see it in every language.

#include <stdio.h>

// function to reverse an array in place
void reverseArray(int arr[], int n) {
    int left = 0;
    int right = n - 1;

    // swap until the two pointers meet
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    reverseArray(arr, n);

    printf("Reversed array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

Reversed array: 5 4 3 2 1

#include <iostream>
using namespace std;

// function to reverse an array in place
void reverseArray(int arr[], int n) {
    int left = 0;
    int right = n - 1;

    // swap until the two pointers meet
    while (left < right) {
        swap(arr[left], arr[right]);
        left++;
        right--;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    reverseArray(arr, n);

    cout << "Reversed array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

Reversed array: 5 4 3 2 1

public class ReverseArray {
    // function to reverse an array in place
    public static void reverseArray(int[] arr) {
        int left = 0;
        int right = arr.length - 1;

        // swap until the two pointers meet
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        reverseArray(arr);

        System.out.print("Reversed array: ");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

Reversed array: 5 4 3 2 1

# function to reverse an array in place
def reverse_array(arr):
    left = 0
    right = len(arr) - 1

    # swap until the two pointers meet
    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1

def main():
    arr = [1, 2, 3, 4, 5]
    reverse_array(arr)
    print("Reversed array:", arr)

if __name__ == "__main__":
    main()

Reversed array: [5, 4, 3, 2, 1]

// function to reverse an array in place
function reverseArray(arr) {
    let left = 0;
    let right = arr.length - 1;

    // swap until the two pointers meet
    while (left < right) {
        [arr[left], arr[right]] = [arr[right], arr[left]];
        left++;
        right--;
    }
}

function main() {
    const arr = [1, 2, 3, 4, 5];
    reverseArray(arr);
    console.log("Reversed array:", arr);
}
main();

Reversed array: [ 5, 4, 3, 2, 1 ]

⏱️ Time and Space Complexity

Both ways look at each element once, so both are O(n) time. The win is in space. The two pointer way only uses a couple of variables, so it is O(1) extra space. That is the answer the interviewer is hoping for.

🧩 Key Takeaways

• ✅ “Reverse an array” almost always means reverse it in place, with O(1) extra space.
• ✅ The two pointer technique swaps the ends and walks inward until the pointers meet.
• ✅ You only loop halfway, because each swap fixes two elements at once.
• ✅ Time is O(n) and extra space is O(1).

🚀 What’s Next?

Now that you have the two pointer trick, try these next:

• Rotate an Array uses array reversal as a clever building block.
• Check Palindrome String uses the same two pointer idea on a string.

Reverse an array shows up everywhere once you learn it. Get the two pointer pattern into your fingers and a whole family of problems gets easier.