Loading…

easyBasicsSometimes asked

Reverse an Array

Basics · 6 min

Given an integer array nums, reverse it in place so the first element becomes the last.

In plain English

Swap the two ends and walk both pointers inward until they meet.

Examples

Example 1

Input: nums = [1, 2, 3, 4]
Output: [4, 3, 2, 1]
Note: Ends swapped inward.

Example 2

Input: nums = [1, 2, 3]
Output: [3, 2, 1]
Note: Middle stays put.

Example 3

Input: nums = [9]
Output: [9]
Note: Single element unchanged.

Constraints

0 ≤ nums.length ≤ 10^5

Clarifying questions1First question: In place or return a new array?Explore questions

Q1.In place or return a new array?
In place with two pointers for O(1) space; I can return a copy if required.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Two pointers — `left = 0`, `right = n-1`. Swap `nums[left]` and `nums[right]`, then move both toward the centre until they cross. O(1) extra space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you reverse in place with two pointers and get the loop bound right.

Where candidates slip

Swapping across the whole array (double swap) or an out-of-bounds right pointer.

How to stand out

Note the same primitive powers reverse-string and the rotation-by-three-reversals trick.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Two-pointer swap

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Pair the first element with the last, second with second-last…

2Hint 2Explore hint

Two pointers from both ends; swap and move inward.

3Hint 3Explore hint

Stop when left meets right — use `<`, not `<=`.

A · Core idea

Reverse in place with the two-pointer swap: left at the start, right at the end, swap them, and step both inward until they meet. O(n) time, O(1) extra space — no second array.

Why pointers converge in the middle. Each swap places two elements in their final positions, so after n/2 swaps every element is reversed. The middle element of an odd-length array is already in place and needs no swap — which is exactly why the loop condition is left < right (strictly), not <=.

Why `<=` would be a bug. With left <= right, the middle element would be swapped with itself (harmless), but more importantly on even lengths the pointers would cross and you'd swap the same pairs back, un-reversing the array. left < right stops cleanly when they meet or cross.

This swap-and-converge primitive underlies reverse-string and the three-reversal array rotation trick.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [1, 2, 3, 4]

l=0,r=3

swap 1 and 4

State[4, 2, 3, 1]

Final result[4, 3, 2, 1]

C · Code with teaching comments

solution.javaJava

Two-pointer swap — optimal

2 teaching notes

1
public void reverse(int[] nums) {
2
    int left = 0, right = nums.length - 1;
3
    while (left < right) {
4
        int tmp = nums[left];
5
        nums[left] = nums[right];
6
        nums[right] = tmp;
7
        left++;
8
        right--;
9
    }
10
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.10 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

The two-pointer swap is the reusable primitive behind reverse-string and the three-reversal rotation.

ComplexityO(n) time, O(1) space — n/2 swaps, each O(1), with only a temp variable — linear time, constant space.

E · Edge cases and pitfalls5nums = [1, 2, 3] — Middle 2 stays; result [3, 2, 1].Explore edge cases

Edge cases handled

nums = [1, 2, 3]Middle 2 stays; result [3, 2, 1].
nums = [9]Loop never runs; unchanged.
nums = []Nothing to do.

Pitfalls

Looping the full length and swapping every pair twice (undoing the reversal).
Off-by-one: right starting at length instead of length − 1.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic void reverse(int[] nums) { int left = 0, right = nums.length - 1; while (left < right) { int tmp = nums[left]; nums[left] = nums[right];Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Swapping the full length

Looping i from 0 to n−1 and swapping nums[i] with nums[n−1−i] swaps every pair twice, leaving the array unchanged.

Explore the code comparison

Don't write this

for (int i = 0; i < n; i++) swap(nums, i, n-1-i);   // double swap

Write this instead

int l = 0, r = n-1; while (l < r) { swap(nums, l++, r--); }

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Two-pointer inward swap

Code pattern to memorize

l=0; r=n-1; while l<r: swap(l,r); l++; r--

Rules to remember

1left=0, right=n-1.
2Swap, then move both in.
3Stop when left ≥ right.

Use this pattern when

In-place reversal
Symmetric two-pointer passes

Interview takeaway

Reverse-in-place = swap the ends and converge.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Two-pointer inward swap. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Same pattern

easyBasicsSometimes asked

Reverse an Array

Basics · 6 min

Given an integer array nums, reverse it in place so the first element becomes the last.

In plain English

Swap the two ends and walk both pointers inward until they meet.

Examples

Example 1

Input: nums = [1, 2, 3, 4]
Output: [4, 3, 2, 1]
Note: Ends swapped inward.

Example 2

Input: nums = [1, 2, 3]
Output: [3, 2, 1]
Note: Middle stays put.

Example 3

Input: nums = [9]
Output: [9]
Note: Single element unchanged.

Constraints

0 ≤ nums.length ≤ 10^5

Clarifying questions1First question: In place or return a new array?Explore questions

Q1.In place or return a new array?
In place with two pointers for O(1) space; I can return a copy if required.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Two pointers — `left = 0`, `right = n-1`. Swap `nums[left]` and `nums[right]`, then move both toward the centre until they cross. O(1) extra space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you reverse in place with two pointers and get the loop bound right.

Where candidates slip

Swapping across the whole array (double swap) or an out-of-bounds right pointer.

How to stand out

Note the same primitive powers reverse-string and the rotation-by-three-reversals trick.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Two-pointer swap

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Pair the first element with the last, second with second-last…

2Hint 2Explore hint

Two pointers from both ends; swap and move inward.

3Hint 3Explore hint

Stop when left meets right — use `<`, not `<=`.

A · Core idea

Reverse in place with the two-pointer swap: left at the start, right at the end, swap them, and step both inward until they meet. O(n) time, O(1) extra space — no second array.

This swap-and-converge primitive underlies reverse-string and the three-reversal array rotation trick.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [1, 2, 3, 4]

l=0,r=3

swap 1 and 4

State[4, 2, 3, 1]

Final result[4, 3, 2, 1]

C · Code with teaching comments

solution.javaJava

Two-pointer swap — optimal

2 teaching notes

1
public void reverse(int[] nums) {
2
    int left = 0, right = nums.length - 1;
3
    while (left < right) {
4
        int tmp = nums[left];
5
        nums[left] = nums[right];
6
        nums[right] = tmp;
7
        left++;
8
        right--;
9
    }
10
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.10 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

The two-pointer swap is the reusable primitive behind reverse-string and the three-reversal rotation.

ComplexityO(n) time, O(1) space — n/2 swaps, each O(1), with only a temp variable — linear time, constant space.

E · Edge cases and pitfalls5nums = [1, 2, 3] — Middle 2 stays; result [3, 2, 1].Explore edge cases

Edge cases handled

nums = [1, 2, 3]Middle 2 stays; result [3, 2, 1].
nums = [9]Loop never runs; unchanged.
nums = []Nothing to do.

Pitfalls

Looping the full length and swapping every pair twice (undoing the reversal).
Off-by-one: right starting at length instead of length − 1.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic void reverse(int[] nums) { int left = 0, right = nums.length - 1; while (left < right) { int tmp = nums[left]; nums[left] = nums[right];Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Swapping the full length

Looping i from 0 to n−1 and swapping nums[i] with nums[n−1−i] swaps every pair twice, leaving the array unchanged.

Explore the code comparison

Don't write this

for (int i = 0; i < n; i++) swap(nums, i, n-1-i);   // double swap

Write this instead

int l = 0, r = n-1; while (l < r) { swap(nums, l++, r--); }

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Two-pointer inward swap

Code pattern to memorize

l=0; r=n-1; while l<r: swap(l,r); l++; r--

Rules to remember

1left=0, right=n-1.
2Swap, then move both in.
3Stop when left ≥ right.

Use this pattern when

In-place reversal
Symmetric two-pointer passes

Interview takeaway

Reverse-in-place = swap the ends and converge.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Two-pointer inward swap. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Same pattern