Move Zeroes - Practice Coding Problems

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

Understanding the Visualization

Input

Array with zeros scattered throughout: [0,1,0,3,12]

Process

Move all non-zero elements to front, maintaining their order

Output

All zeros moved to end: [1,3,12,0,0]

Key Takeaway

🎯 Key Insight: Use two pointers - one tracks the position for the next non-zero element

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

Approach	Time	Space	Notes
✓ Two Pointers - Optimal In-Place	O(n)	O(1)	Use one pointer to track position for non-zeros, another to scan the array
Brute Force - Remove and Append	O(n²)	O(1)	Remove each zero and append it to the end, shifting elements each time

Two Pointers - Optimal In-Place — Algorithm Steps

Initialize slow pointer at 0 to track position for next non-zero
Use fast pointer to scan through entire array
When fast pointer finds non-zero, copy it to slow pointer position and increment slow
After processing, fill remaining positions with zeros

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set slow=0 (next non-zero position), fast scans array

Copy Non-zeros

When fast finds non-zero, copy to slow position and increment slow

Fill Zeros

After scanning, fill remaining positions with zeros

Code -

solution.c — C

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

void solution(int* nums, int numsSize) {
    int slow = 0; // Position for next non-zero element
    
    // First pass: move all non-zero elements to front
    for (int fast = 0; fast < numsSize; fast++) {
        if (nums[fast] != 0) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    
    // Second pass: fill remaining positions with zeros
    while (slow < numsSize) {
        nums[slow] = 0;
        slow++;
    }
}

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)

Single pass through the array with fast pointer, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no extra arrays

✓ 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

Two Pointers - Optimal In-Place — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler