Move Zeroes

Move Zeroes - Problem

Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.

Note: You must do this in-place without making a copy of the array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [0,1,0,3,12]

› Output: [1,3,12,0,0]

💡 Note: Move all zeros to the end while keeping non-zero elements in same relative order: 1, 3, 12 stay in order, zeros move to end

Example 2 — No Zeros

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

› Output: [1,2,3]

💡 Note: No zeros present, array remains unchanged

Example 3 — All Zeros

$ Input: nums = [0,0,0]

› Output: [0,0,0]

💡 Note: All elements are zeros, array remains the same

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 25 M Microsoft 20 A Apple 15 G Google 12

The key insight is to use two pointers to efficiently move non-zero elements to the front in a single pass. Best approach uses two pointers with one tracking the position for the next non-zero element. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Remove and Append

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

For each zero found, remove it from its current position and append it to the end. This requires shifting all subsequent elements left for each removal, making it inefficient.

Two Pointers - Optimal In-Place

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

Use two pointers: one (slow) tracks the position where the next non-zero element should be placed, and another (fast) scans through the array. When we find a non-zero, we place it at the slow pointer position.

Brute Force - Remove and Append — Algorithm Steps

Find the first zero in the array
Remove it and shift all elements after it to the left
Append the zero to the end
Repeat until no more zeros are found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Zero

Locate the first zero in the array

Remove & Shift

Remove zero and shift all elements left

Append Zero

Add the zero to the end of array

Code -

solution.c — C

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

void solution(int* nums, int numsSize) {
    int nonZeros[10000];
    int nonZeroCount = 0;
    int zeroCount = 0;
    
    // Collect non-zeros and count zeros
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 0) {
            zeroCount++;
        } else {
            nonZeros[nonZeroCount++] = nums[i];
        }
    }
    
    // Reconstruct array
    for (int i = 0; i < numsSize; i++) {
        if (i < nonZeroCount) {
            nums[i] = nonZeros[i];
        } else {
            nums[i] = 0;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[100];
    int size = 0;
    char* token = strtok(line, "[],");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    solution(nums, size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", nums[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each zero (up to n), we shift all remaining elements left, resulting in n×n operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra arrays needed

✓ Linear Space

299.0K Views

High Frequency

~15 min Avg. Time

8.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Remove and Append — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler