Move Zeroes - Practice Coding Problems

Move Zeroes - Problem

Given an integer array nums, you need to move all zeros to the end while keeping the relative order of non-zero elements intact. This is like organizing a bookshelf where you want to push all the empty spaces to one end!

The challenge is that you must do this in-place without creating a new array. Think of it as rearranging items on a conveyor belt without stopping the belt.

Example: [0,1,0,3,12] becomes [1,3,12,0,0]

Goal: Transform the array so all zeros are at the end, non-zero elements maintain their original relative positions, and you use O(1) extra space.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Move all zeros to the end while maintaining the relative order of non-zero elements. The non-zero elements 1, 3, 12 keep their relative positions, and zeros are moved to the end.

example_2.py — Single Zero

$ Input: [0]

› Output: [0]

💡 Note: Array with single zero remains unchanged as there are no non-zero elements to rearrange.

example_3.py — No Zeros

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

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

💡 Note: Array with no zeros remains unchanged as there are no zeros to move. All elements maintain their original positions.

Constraints

1 ≤ nums.length ≤ 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Follow up: Could you minimize the total number of operations done?

Visualization

Tap to expand

Understanding the Visualization

Identify Books and Gaps

Scan the shelf to find books (non-zeros) and empty spots (zeros)

Move Books Left

Slide each book to the leftmost available position

Fill Right with Gaps

All empty spots naturally end up on the right side

Maintain Order

Books keep their relative positions throughout the process

Key Takeaway

🎯 Key Insight: Instead of moving zeros (expensive), focus on moving non-zeros to their correct positions - zeros naturally end up at the end!

Asked in

f Facebook 45 a Amazon 38 ⊞ Microsoft 32 G Google 28

The optimal solution uses a two-pointer approach with O(n) time complexity. Use a write pointer to track where non-zero elements should be placed, and iterate with a read pointer. Copy non-zeros to write positions, then fill remaining spots with zeros. This avoids expensive shifting operations and processes each element exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use one pointer to find non-zeros and another to place them optimally
Brute Force (Remove and Append)	O(n²)	O(1)	Remove zeros one by one and append them to the end

Two Pointers (Optimal) — Algorithm Steps

Initialize write pointer at index 0
Use read pointer to iterate through entire array
When read pointer finds non-zero element, copy it to write position
Increment write pointer after each non-zero placement
Fill remaining positions with zeros

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set write pointer at start, read pointer will iterate

Copy Non-zeros

When read finds non-zero, copy to write position and advance write

Skip Zeros

Read pointer continues, write pointer stays for zeros

Fill Remaining

Fill remaining positions with zeros

Code -

solution.c — C

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

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

int main() {
    int nums[] = {0, 1, 0, 3, 12};
    int size = 5;
    moveZeroes(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 each element processed exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no extra arrays or significant additional space

✓ Linear Space

89.3K Views

High Frequency

~15 min Avg. Time

2.8K 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) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler