Reverse Array using Two Pointers - Visualization

Arrays

Contents

VisualizationProblemExamplesSolutionAlgorithmCodeTimeSpaceDetailed Ex

Visualization Player

Problem Statement❯

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.

Examples❯

Input Array Reversed Output Description
[1, 2, 3, 4, 5] [5, 4, 3, 2, 1] Normal case with odd number of elementsVisualization
[10, 20, 30, 40] [40, 30, 20, 10] Normal case with even number of elementsVisualization
[100] [100] Single-element array remains unchangedVisualization
[] [] Empty array returns empty result (edge case)Visualization

Solution❯

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: []

Algorithm Steps❯

  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.

Code

C
C++
Python
Java
JS
Go
Rust
Kotlin
Swift
TS
#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;
}

Time Complexity❯

CaseTime ComplexityExplanation
Best CaseO(n)Even in the best case, the algorithm must visit each element once to perform the swap. So the time complexity is linear in all cases.
Average CaseO(n)Each pair of elements is visited and swapped once, so the total operations grow linearly with the size of the array.
Worst CaseO(n)All elements need to be swapped exactly once with their mirror index, requiring n/2 swaps — still considered O(n).

Space Complexity❯

O(1)

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

Detailed Step by Step Example❯

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

{ "array": [6,3,8,2,7,4], "showIndices": true, "specialIndices": [] }

Pass 1

left = 0, right = 5

Swap elements at left index and right index.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [0, 5], "highlightIndicesGreen": [], "specialIndices": [], "labels": { "0": "left", "5": "right" } }

After swapping:

{ "array": [4,3,8,2,7,6], "showIndices": true, "highlightIndicesGreen": [0,5], "labels": { "0": "left", "5": "right" } }
Increment left pointer by one, and decrement right pointer by one.

Pass 2

left = 1, right = 4

Swap elements at left index and right index.

{ "array": [4,3,8,2,7,6], "showIndices": true, "highlightIndices": [1, 4], "highlightIndicesGreen": [0,5], "specialIndices": [], "labels": { "1": "left", "4": "right" } }

After swapping:

{ "array": [4,7,8,2,3,6], "showIndices": true, "highlightIndicesGreen": [0,1,4,5], "labels": { "1": "left", "4": "right" } }
Increment left pointer by one, and decrement right pointer by one.

Pass 3

left = 2, right = 3

Swap elements at left index and right index.

{ "array": [4,7,8,2,3,6], "showIndices": true, "highlightIndices": [2, 3], "highlightIndicesGreen": [0,1,4,5], "specialIndices": [], "labels": { "2": "left", "3": "right" } }

After swapping:

{ "array": [4,7,2,8,3,6], "showIndices": true, "highlightIndicesGreen": [0,1,2,3,4,5], "labels": { "2": "left", "3": "right" } }
Increment left pointer by one, and decrement right pointer by one.

left = 3, right = 2

left pointer crosses right pointer, end of loop.

Array is fully reversed.

{ "array": [4,7,2,8,3,6], "showIndices": true, "highlightIndicesGreen": [0,1,2,3,4,5], "specialIndices": [] }

Comments

💬 Please keep your comment relevant and respectful. Avoid spamming, offensive language, or posting promotional/backlink content.
All comments are subject to moderation before being published.

Loading comments...