Array Reversal

Array reversal rearranges elements so that the first becomes the last, the second becomes the second last, and so on.

You use it as a basic primitive in many algorithms, including rotation, palindrome checks, and two-pointer techniques.

Problem

Given an array $A$ of length $n$ , transform it into:

A' = [a_{n-1}, a_{n-2}, \dots, a_0]

Algorithm

Use two pointers from both ends and swap elements until they meet.

reverse(A):
    l = 0
    r = length(A) - 1

    while l < r:
        swap A[l], A[r]
        l += 1
        r -= 1

Example

Let

A = [8, 3, 5, 1, 9]

step	l	r	array
1	0	4	[9, 3, 5, 1, 8]
2	1	3	[9, 1, 5, 3, 8]
3	2	2	stop

Result:

[9, 1, 5, 3, 8]

Correctness

At each step, the algorithm swaps symmetric elements around the center. After $k$ steps, positions $0$ through $k-1$ and $n-k$ through $n-1$ are in their correct reversed positions.

When the pointers meet or cross, all positions have been processed exactly once, so the array is fully reversed.

Complexity

operation	time
reverse	$O(n)$

Space usage:

O(1)

When to Use

Array reversal is appropriate when:

reversing order is required
used as a building block for other algorithms
in-place transformation is preferred

It is less suitable when:

the original array must remain unchanged
immutability is required, in which case create a copy

Implementation

def reverse(a):
    l, r = 0, len(a) - 1
    while l < r:
        a[l], a[r] = a[r], a[l]
        l += 1
        r -= 1

func Reverse[T any](a []T) {
    l, r := 0, len(a)-1
    for l < r {
        a[l], a[r] = a[r], a[l]
        l++
        r--
    }
}