Loading…

easyBasicsSometimes asked

Move Zeros to End

Basics · 6 min

Given an integer array nums, move every 0 to the end while keeping the order of the non-zero elements. Do it in place.

In plain English

Use a write pointer: copy each non-zero forward, then fill the rest with zeros.

Examples

Example 1

Input: nums = [0, 1, 0, 3, 12]
Output: [1, 3, 12, 0, 0]
Note: Non-zeros keep order.

Example 2

Input: nums = [0, 0, 1]
Output: [1, 0, 0]
Note: One non-zero moves up.

Example 3

Input: nums = [1, 2, 3]
Output: [1, 2, 3]
Note: No zeros — unchanged.

Constraints

1 ≤ nums.length ≤ 10^5

Clarifying questions2First question: Must order of non-zeros be preserved?Explore questions

Q1.Must order of non-zeros be preserved?
Yes — this is a stable partition; I preserve it.
Q2.In place?
Yes, O(1) extra space with a write pointer.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

A stable partition: keep an `insert` index, copy each non-zero element to `nums[insert++]`, then zero-fill from `insert` to the end. O(n) time, O(1) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can do a stable in-place partition with a write pointer.

Where candidates slip

Reordering non-zeros, or leaving stale values in the tail.

How to stand out

Mention the single-pass swap variant and the shared pattern with remove-element.

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

Write-pointer partition

TimeO(n)SpaceO(1)

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

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Keep a write index for where the next non-zero should land.

2Hint 2Explore hint

Copy non-zeros forward in order; what's left over must be zeros.

3Hint 3Explore hint

Fill from the write index to the end with 0.

A · Core idea

Compact the non-zeros to the front with a write pointer, then fill the rest with zeros. This is a stable in-place partition: O(n) time, O(1) space, and the non-zeros keep their original order.

How the write pointer works. insert marks where the next kept element goes. Scanning left to right, every time you see a non-zero you copy it to nums[insert] and advance insert. Because you read and write left to right and the write index never outpaces the read index, you never clobber an unread value — and the relative order of non-zeros is preserved.

Why the second loop. After compaction, indices insert..n−1 hold stale values; overwrite them with 0. The count of zeros equals n − insert, automatically.

The swap variant. You can also swap a non-zero at the read pointer with the slot at the write pointer, avoiding the second pass — but the copy-then-fill version is the clearest to reason about. This compaction pattern reappears in 'remove element' and 'remove duplicates from sorted array'.

B · Visual dry run

Interactive dry run

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

nums = [0, 1, 0, 3, 12]

skip

Stateinsert=0

Final result[1, 3, 12, 0, 0]

C · Code with teaching comments

solution.javaJava

Write-pointer partition — optimal

2 teaching notes

1
public void moveZeros(int[] nums) {
2
    int insert = 0;
3
    for (int x : nums) {
4
        // Compact non-zeros to the front, preserving order.
5
        if (x != 0) nums[insert++] = x;
6
    }
7
    while (insert < nums.length) {
8
        nums[insert++] = 0;
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

This stable-partition pattern (compact, then fill) reappears in 'remove element' and 'remove duplicates from sorted array'.

ComplexityO(n) time, O(1) space — two linear passes (compact, then fill) with only an index variable — O(n) time, O(1) space.

E · Edge cases and pitfalls5nums = [0, 0, 1] — One non-zero compacts → [1, 0, 0].Explore edge cases

Edge cases handled

nums = [0, 0, 1]One non-zero compacts → [1, 0, 0].
nums = [1, 2, 3]No zeros → unchanged.
nums = [0, 0, 0]All zeros → unchanged after fill.

Pitfalls

Swapping in a way that reorders the non-zeros.
Forgetting to zero-fill the remaining slots.

Practice

Try the solution yourself

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

Editable code previewpublic void moveZeros(int[] nums) { int insert = 0; for (int x : nums) { if (x != 0) nums[insert++] = x; }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 in a way that reorders the non-zeros.
Forgetting to zero-fill the remaining slots.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Stable write-pointer partition

Code pattern to memorize

insert=0; for x: if x!=0: a[insert++]=x; fill a[insert..] = 0

Rules to remember

1Compact keepers to the front.
2Fill the rest with the removed value.
3Order preserved.

Use this pattern when

In-place remove/move with order preserved

Interview takeaway

A write index turns 'remove/move X' into one in-place pass.

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: Stable write-pointer partition. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Remove Element
Coming soon
Same write-pointer compaction for a target value.
Remove Duplicates from Sorted Array
Coming soon
Write-pointer keeps the first of each run.

Same pattern

easyBasicsSometimes asked

Move Zeros to End

Basics · 6 min

Given an integer array nums, move every 0 to the end while keeping the order of the non-zero elements. Do it in place.

In plain English

Use a write pointer: copy each non-zero forward, then fill the rest with zeros.

Examples

Example 1

Input: nums = [0, 1, 0, 3, 12]
Output: [1, 3, 12, 0, 0]
Note: Non-zeros keep order.

Example 2

Input: nums = [0, 0, 1]
Output: [1, 0, 0]
Note: One non-zero moves up.

Example 3

Input: nums = [1, 2, 3]
Output: [1, 2, 3]
Note: No zeros — unchanged.

Constraints

1 ≤ nums.length ≤ 10^5

Clarifying questions2First question: Must order of non-zeros be preserved?Explore questions

Q1.Must order of non-zeros be preserved?
Yes — this is a stable partition; I preserve it.
Q2.In place?
Yes, O(1) extra space with a write pointer.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

A stable partition: keep an `insert` index, copy each non-zero element to `nums[insert++]`, then zero-fill from `insert` to the end. O(n) time, O(1) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can do a stable in-place partition with a write pointer.

Where candidates slip

Reordering non-zeros, or leaving stale values in the tail.

How to stand out

Mention the single-pass swap variant and the shared pattern with remove-element.

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

Write-pointer partition

TimeO(n)SpaceO(1)

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

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Keep a write index for where the next non-zero should land.

2Hint 2Explore hint

Copy non-zeros forward in order; what's left over must be zeros.

3Hint 3Explore hint

Fill from the write index to the end with 0.

A · Core idea

Compact the non-zeros to the front with a write pointer, then fill the rest with zeros. This is a stable in-place partition: O(n) time, O(1) space, and the non-zeros keep their original order.

Why the second loop. After compaction, indices insert..n−1 hold stale values; overwrite them with 0. The count of zeros equals n − insert, automatically.

B · Visual dry run

Interactive dry run

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

nums = [0, 1, 0, 3, 12]

skip

Stateinsert=0

Final result[1, 3, 12, 0, 0]

C · Code with teaching comments

solution.javaJava

Write-pointer partition — optimal

2 teaching notes

1
public void moveZeros(int[] nums) {
2
    int insert = 0;
3
    for (int x : nums) {
4
        // Compact non-zeros to the front, preserving order.
5
        if (x != 0) nums[insert++] = x;
6
    }
7
    while (insert < nums.length) {
8
        nums[insert++] = 0;
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

This stable-partition pattern (compact, then fill) reappears in 'remove element' and 'remove duplicates from sorted array'.

ComplexityO(n) time, O(1) space — two linear passes (compact, then fill) with only an index variable — O(n) time, O(1) space.

E · Edge cases and pitfalls5nums = [0, 0, 1] — One non-zero compacts → [1, 0, 0].Explore edge cases

Edge cases handled

nums = [0, 0, 1]One non-zero compacts → [1, 0, 0].
nums = [1, 2, 3]No zeros → unchanged.
nums = [0, 0, 0]All zeros → unchanged after fill.

Pitfalls

Swapping in a way that reorders the non-zeros.
Forgetting to zero-fill the remaining slots.

Practice

Try the solution yourself

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

Editable code previewpublic void moveZeros(int[] nums) { int insert = 0; for (int x : nums) { if (x != 0) nums[insert++] = x; }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 in a way that reorders the non-zeros.
Forgetting to zero-fill the remaining slots.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Stable write-pointer partition

Code pattern to memorize

insert=0; for x: if x!=0: a[insert++]=x; fill a[insert..] = 0

Rules to remember

1Compact keepers to the front.
2Fill the rest with the removed value.
3Order preserved.

Use this pattern when

In-place remove/move with order preserved

Interview takeaway

A write index turns 'remove/move X' into one in-place pass.

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: Stable write-pointer partition. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Remove Element
Coming soon
Same write-pointer compaction for a target value.
Remove Duplicates from Sorted Array
Coming soon
Write-pointer keeps the first of each run.

Same pattern