Reverse Array using Two Pointers

Contents

ProblemExamplesVisualizationSolutionAlgorithmCodeTimeSpace Detailed Exmpl

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

Visualization Player

Solution❯

Reversing an array is a classic problem and can be solved efficiently using the two pointers approach. The idea is simple: swap the elements from both ends of the array while gradually moving inward.

Understanding with Examples

Suppose we have the array [1, 2, 3, 4, 5]. We place one pointer at the start (index 0, value 1) and another at the end (index 4, value 5). We swap them to get [5, 2, 3, 4, 1]. Then, we move the pointers inward—next swap 2 and 4—and eventually reach the center (3), which doesn’t need to move. The array is now reversed.

What Happens in Other Cases?

  • Even-Length Arrays: Like [10, 20, 30, 40] — both sides are swapped until the middle is crossed. No element is left untouched.
  • Odd-Length Arrays: Like [1, 3, 5] — the center element (3) doesn’t move because it’s already in its correct reversed spot.
  • Single-Element Arrays: An array like [100] stays the same after reversal. Nothing changes because there’s only one element.
  • Empty Arrays: For an empty array [], there’s nothing to reverse. The result is also an empty array. No swaps happen.
  • Mixed Types: Whether it’s strings, booleans, or other values, the same logic applies. We just swap positions, not data types.

Why It’s Efficient

This approach doesn’t use any extra array or space—it modifies the array in-place. The total number of swaps is half the length of the array. And since every element is touched only once, the time complexity is O(n) with space complexity O(1).

This is a great introductory problem to understand how pointers work and how they can be used to solve array manipulation tasks efficiently.

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

Python
Java
JavaScript
C
C++
C#
Kotlin
Swift
Go
Php
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))

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