Reverse Array using Two Pointers

Given an array of elements, your task is to reverse the array in-place using the two pointers technique.

• Use one pointer starting from the beginning of the array (left), and one from the end (right).
• Swap the elements at these two pointers and move them towards each other until they meet or cross.

The goal is to reverse the order of elements in the array without using extra space.

Step-by-Step Solution to Reverse an Array

Step 1: Understanding the Problem

We are given an array, and our goal is to reverse its elements. That means the first element should become the last, the second becomes the second last, and so on. We want to solve this using an efficient method that doesn't use extra space.

Step 2: Strategy - Two Pointers Approach

We will use two pointers: one starting at the beginning of the array, and the other at the end. In each step, we will swap the values at these two positions and move the pointers closer until they meet.

Example: Let's Reverse [10, 20, 30, 40, 50]

1. Start with the array: [10, 20, 30, 40, 50]
2. We place the start pointer at index 0 (value = 10), and the end pointer at index 4 (value = 50)
3. Swap the values at index 0 and index 4 → Array becomes [50, 20, 30, 40, 10]
4. Move start pointer to index 1, end pointer to index 3
5. Swap the values at index 1 and index 3 → Array becomes [50, 40, 30, 20, 10]
6. Now both pointers move to index 2. Since this is the center, we stop here.

Final reversed array: [50, 40, 30, 20, 10]

This approach ensures that every pair is swapped once and the middle element (if any) remains in place without needing any change.

What About Edge Cases?

Even-Length Arrays

Example: [10, 20, 30, 40]

Swaps: 10 & 40, 20 & 30 → Result: [40, 30, 20, 10]

Odd-Length Arrays

Example: [1, 3, 5]

Swaps: 1 & 5 → Center value 3 stays as-is → Result: [5, 3, 1]

Single-Element Arrays

Example: [100]

No swaps needed. Output remains the same: [100]

Empty Arrays

Example: []

No elements, no swaps. Output is still: []

1. Initialize two pointers: one at the beginning (left) and one at the end (right) of the array.
2. While left is less than right, swap the elements at these pointers.
3. Increment left and decrement right to move towards the center of the array.
4. Continue until left is no longer less than right.
5. The array is now reversed.

Worked example

Let us take the following array and apply the Two Pointers Technique to reverse the array in-place.

Pass 1

left = 0, right = 5

Swap elements at left index and right index.

After swapping:

Pass 2

left = 1, right = 4

Swap elements at left index and right index.

After swapping:

Pass 3

left = 2, right = 3

Swap elements at left index and right index.

After swapping:

left = 3, right = 2

left pointer crosses right pointer, end of loop.

Array is fully reversed.

#include <stdio.h>

void reverseArray(int arr[], int n) {
    int left = 0, right = n - 1;
    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]);
    }
    return 0;
}

#include <iostream>
using namespace std;

void reverseArray(int arr[], int n) {
    int left = 0, right = n - 1;
    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);
    cout << "Reversed array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

def reverse_array(arr):
    left, right = 0, len(arr) - 1
    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
    return arr

if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5]
    print("Reversed array:", reverse_array(arr))

public class ReverseArray {
    public static void reverseArray(int[] arr) {
        int left = 0, right = arr.length - 1;
        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 num : arr) {
            System.out.print(num + " ");
        }
    }
}

function reverseArray(arr) {
    let left = 0, right = arr.length - 1;
    while (left < right) {
        [arr[left], arr[right]] = [arr[right], arr[left]];
        left++;
        right--;
    }
    return arr;
}

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

package main
import "fmt"

func reverseArray(arr []int) []int {
    left, right := 0, len(arr)-1
    for left < right {
        arr[left], arr[right] = arr[right], arr[left]
        left++
        right--
    }
    return arr
}

func main() {
    arr := []int{1, 2, 3, 4, 5}
    fmt.Println("Reversed array:", reverseArray(arr))
}

fn reverse_array(arr: &mut [i32]) {
    let mut left = 0;
    let mut right = arr.len() - 1;
    while left < right {
        arr.swap(left, right);
        left += 1;
        right -= 1;
    }
}

fn main() {
    let mut arr = [1, 2, 3, 4, 5];
    reverse_array(&mut arr);
    print!("Reversed array: ");
    for num in arr.iter() {
        print!("{} ", num);
    }
}

fun reverseArray(arr: IntArray): IntArray {
    var left = 0
    var right = arr.size - 1
    while (left < right) {
        val temp = arr[left]
        arr[left] = arr[right]
        arr[right] = temp
        left++
        right--
    }
    return arr
}

fun main() {
    val arr = intArrayOf(1, 2, 3, 4, 5)
    println("Reversed array: " + reverseArray(arr).joinToString(" "))
}

func reverseArray(_ arr: inout [Int]) {
    var left = 0
    var right = arr.count - 1
    while left < right {
        arr.swapAt(left, right)
        left += 1
        right -= 1
    }
}

var arr = [1, 2, 3, 4, 5]
reverseArray(&arr)
print("Reversed array:", arr)

function reverseArray(arr: number[]): number[] {
    let left = 0, right = arr.length - 1;
    while (left < right) {
        [arr[left], arr[right]] = [arr[right], arr[left]];
        left++;
        right--;
    }
    return arr;
}

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

Time complexity

Space complexity

O(1)

Only a constant amount of extra space is used — two pointers and a temporary variable for swapping. The reversal is done in-place.