LeetCode · #283

Move Zeroes Solution

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

Section One · Problem

Problem Statement

🏷️

Difficulty

Easy

🔗

LeetCode

Problem #283

🏗️

Pattern

Two Pointers — read/write compaction

Given an integer array nums, move all 0's to the end of the array while maintaining the relative order of the non-zero elements. You must do this in-place without making a copy of the array.

Example

 Input: nums = [0, 1, 0, 3, 12]
Output: [1, 3, 12, 0, 0]
// Non-zeros maintain order: 1, 3, 12. Zeros pushed to end. 

Constraints

 • 1 ≤ nums.length ≤ 10⁴ • -2³¹ ≤ nums[i] ≤ 2³¹ − 1 • Must be done in-place — no extra array 

Section Two · Approach 1

Brute Force — Extra Array O(n)

Create a new array. First copy all non-zero elements, then fill the rest with zeros. Copy back to the original. Correct but violates the in-place constraint.

Why we can do better

Problem: Uses O(n) extra space. The read/write pointer technique compacts non-zeros forward in a single pass, then fills trailing positions with zeros — all in-place with O(1) space.

Java — Extra Array

 class Solution {
public void moveZeroes(int[] nums) {
int[] temp = new int[nums.length];
int idx = 0;
for (int n : nums)
if (n != 0) temp[idx++] = n;
System.arraycopy(temp, 0, nums, 0, nums.length);
    }
}

Python — Extra Array

 class Solution:
def moveZeroes(self, nums: list[int]) -> None:
        non_zeros = [x for x in nums if x != 0]
        nums[:] = non_zeros + [0] * (len(nums) - len(non_zeros))

Metric	Value
Time	O(n)
Space	O(n) — violates in-place requirement

Section Three · Approach 2

Read/Write Pointer — O(n) time, O(1) space

Use a write pointer that tracks where the next non-zero should go. A read pointer scans the array. When the reader finds a non-zero value, swap it into the writer's position and advance both. Zeros naturally accumulate at the end.

💡 Mental model: Imagine a conveyor belt with mixed packages and empty boxes. A worker (write pointer) stands at the start. A scanner (read pointer) moves along the belt. Every time the scanner finds an actual package, it swaps it to the worker's position, and the worker steps forward. Empty boxes slide to the end naturally.

Algorithm

Step 1: Initialize write = 0.
Step 2: For each read from 0 to n−1: if nums[read] ≠ 0, swap nums[write] and nums[read], then write++.
Step 3: After the loop, all non-zeros are compacted to positions 0..write−1, and zeros fill write..n−1.

🎯 When to recognize this pattern:

Any problem asking to partition or compact an array in-place — move certain elements to one side, remove duplicates (LC 26), or segregate values.
The signal is "rearrange in-place preserving relative order." The read/write (or slow/fast) pointer pattern appears in LC 283, LC 26 (Remove Duplicates), LC 27 (Remove Element), and LC 75 (Sort Colors).

Section Four · Trace

Visual Walkthrough

Trace through nums = [0, 1, 0, 3, 12]:

Read/Write Pointer — compact non-zeros forward

Section Five · Implementation

Code — Java & Python

Java — Read/Write Swap

 class Solution {
public void moveZeroes(int[] nums) {
int write = 0;
for (int read = 0; read < nums.length; read++) {
if (nums[read] != 0) {
int temp = nums[write]; // swap write ↔ read
nums[write] = nums[read];
                nums[read] = temp;
                write++;
            }
        }
    }
}

Python — Read/Write Swap

 class Solution:
def moveZeroes(self, nums: list[int]) -> None:
        write = 0 for read in range(len(nums)):
if nums[read] != 0:
                nums[write], nums[read] = nums[read], nums[write]
                write += 1 

Section Six · Analysis

Complexity Analysis

Approach	Time	Space	Trade-off
Extra Array	O(n)	O(n)	Simple but violates in-place constraint
Two-pass (compact + fill)	O(n)	O(1)	First pass moves non-zeros, second fills zeros
Swap ← optimal	O(n)	O(1)	Single pass, in-place swap. Minimizes writes.

Section Seven · Edge Cases

Edge Cases & Pitfalls

Case	Input	Why It Matters
No zeros	`[1, 2, 3]`	Write follows read exactly — array unchanged. Zero swaps with itself.
All zeros	`[0, 0, 0]`	Write never advances — all elements stay zero.
Single element	`[0]` or `[5]`	Trivial — nothing to move.
Zeros at end	`[1, 2, 0, 0]`	Already in correct position — write catches up, self-swaps.
Negative numbers	`[0, -1, 0, -3]`	Negatives are non-zero — treated like any other value.

⚠ Common Mistake: Using assignment instead of swap: nums[write] = nums[read] without zeroing nums[read]. This leaves the original non-zero in place, creating duplicates. Always swap — or use a two-pass approach where you fill zeros explicitly after compacting.

← Back to Two Pointers problems

LearningTree

LC 283 · Move Zeroes — Solution & Explanation | DSA Guide