Array Reversal - Problem

Given an array of integers, reverse the array in-place without using any additional array or extra space.

The reversal should be done by modifying the original array directly, swapping elements from both ends moving towards the center.

For example, if the input array is [1, 2, 3, 4, 5], the output should be [5, 4, 3, 2, 1].

Constraints:

You must reverse the array in-place (O(1) extra space)
Do not create a new array
Handle edge cases like empty arrays and single elements

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3,4,5]

› Output: [5,4,3,2,1]

💡 Note: Reverse the array in-place: first element becomes last, last becomes first, and so on

Example 2 — Even Length Array

$ Input: nums = [1,2,3,4]

› Output: [4,3,2,1]

💡 Note: With even length, pointers meet exactly in the middle after swapping all pairs

Example 3 — Single Element

$ Input: nums = [42]

› Output: [42]

💡 Note: Single element array remains unchanged - pointers start equal so no swaps needed

Constraints

1 ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

M Microsoft 25 A Amazon 20 G Google 15 🍎 Apple 12

The key insight is using two pointers from opposite ends to swap elements while moving toward the center. The two-pointers approach achieves true in-place reversal with optimal Time: O(n), Space: O(1) complexity.

Common Approaches

✓ Brute Force - Extra Array

⏱️ Time: O(n) Space: O(n)

Create a temporary array of the same size, then copy elements from the original array to the new array in reverse order, finally copy back to the original array.

Two Pointers - In-Place Reversal

⏱️ Time: O(n) Space: O(1)

Place one pointer at the beginning and another at the end of the array. Swap the elements at these positions, then move pointers toward each other until they meet in the middle.

Brute Force - Extra Array — Algorithm Steps

Create temporary array of same size
Copy elements in reverse order to temp array
Copy back from temp array to original array

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Temp Array

Allocate new array of same size

Copy Reverse

Copy elements from end to start into temp

Copy Back

Copy from temp back to original array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* temp = (int*)malloc(numsSize * sizeof(int));
    
    // Copy elements in reverse order
    for (int i = 0; i < numsSize; i++) {
        temp[i] = nums[numsSize - 1 - i];
    }
    
    // Copy back to original array
    for (int i = 0; i < numsSize; i++) {
        nums[i] = temp[i];
    }
    
    free(temp);
    return nums;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char *ptr = strchr(line, '[');
    ptr++;
    
    char *token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through array to copy elements

✓ Linear Growth

Space Complexity

O(n)

Extra array of size n for temporary storage

⚡ Linearithmic Space

30.6K Views

High Frequency

~8 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Array Reversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Extra Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler