easy Move Zeroes

Problem Statement

Given an array of integers nums, move all the 0s, which are present in the array to the end while maintaining the relative order of the non-zero elements.

Note: This rearrangement should be done in-place without using extra space for another array.

Example 1:

Input: [1, 0, 2, 0, 3, 0, 4]
Expected Output: [1, 2, 3, 4, 0, 0, 0]
Justification: Here, all non-zero elements (1, 2, 3, 4) retain their order, and all zeros are moved to the end of the array.

Example 2:

Input: [0, 0, 0, 10, 20]
Expected Output: [10, 20, 0, 0, 0]
Justification: The non-zero elements (10, 20) are shifted to the front, and the zeros are relocated to the end.

Example 3:

Input: [5, 1, 0, 2, 0]
Expected Output: [5, 1, 2, 0, 0]
Justification: Non-zero elements (5, 1, 2) maintain their sequence, while zeros are moved to the end.

Try it yourself

Try solving this question here:

🎯 STRICT STANDOUT — Move Zeroes — problem

1. Why / judgment

Stable in-place partition: all nonzeros keep relative order, zeros go to the end. This is the write-pointer / read-pointer pattern (same family as remove element), not full sort (sorting would reorder nonzeros).

2. Big-O derivation (K11)

One pass write nonzeros then fill zeros: O(n) time O(1) space.
Two-array copy: O(n) time O(n) space — violates in-place note.

3. Pattern + when-NOT (K12)

Name: TWO POINTERS / STABLE PARTITION (WRITE INDEX)

Recognition: move all zeros to end; preserve nonzero order; in-place.

When-NOT: Need sort by other keys → comparator sort. Need move zeros to front → symmetric write from end or reverse predicate. Need minimize writes under sparse zeros → optional swap-only variant.

4. Edge hand-run (K13)

all zeros → already done.
no zeros → no moves.
leading zeros [0,0,1] → [1,0,0].
single [0] / [5].

5. Interviewer follow-ups (model answers)

Q1. Why not sort with zeros last?
A: Comparator sort is O(n log n) and may reorder equal nonzeros depending on stability; write-pointer is linear and order-preserving.

Q2. Is swap-based two pointer OK?
A: Yes if you only swap nonzero into place; still O(n).

Q3. Extra array allowed?
A: Problem says no; interviews may still ask O(n) space first then optimize.

6. Short drills

Drill: [1,0,2,0,3,0,4] → [1,2,3,4,0,0,0].
Drill: count writes for almost-no-zeros array.

✅ Solution Move Zeroes

Problem Statement

Given an array of integers nums, move all the 0s present in the array to the end while maintaining the relative order of the non-zero elements.

Note: This rearrangement should be done in-place without using extra space for another array.

Example 1:

Input: [1, 0, 2, 0, 3, 0, 4]
Expected Output: [1, 2, 3, 4, 0, 0, 0]
Justification: Here, all non-zero elements (1, 2, 3, 4) retain their order, and all zeros are moved to the end of the array.

Example 2:

Input: [0, 0, 0, 10, 20]
Expected Output: [10, 20, 0, 0, 0]
Justification: The non-zero elements (10, 20) are shifted to the front, and the zeros are relocated to the end.

Example 3:

Input: [5, 1, 0, 2, 0]
Expected Output: [5, 1, 2, 0, 0]
Justification: Non-zero elements (5, 1, 2) maintain their sequence, while zeros are moved to the end.

Solution

To solve this problem, we will use a two-pointer approach. The first pointer (i) will iterate over the array, and the second pointer (lastNonZeroIndex) will keep track of the position where the next non-zero element should be placed.

This approach is efficient as it allows us to perform the operation in-place, reducing the space complexity. It's also effective because it ensures that the relative order of non-zero elements is maintained by sequentially filling non-zero elements from the start. As we iterate through the array, we swap non-zero elements with the element at the lastNonZeroIndex and increment lastNonZeroIndex. This method is optimal as it requires a single pass over the array, ensuring linear time complexity.

Step-by-step algorithm

Initialize lastNonZeroIndex to 0.
Iterate through each element (i) in the array:
- If the current element is not zero:
  - Swap the element at i with the element at lastNonZeroIndex.
  - Increment lastNonZeroIndex.
This process groups all non-zero elements at the beginning of the array and zeros at the end, maintaining their original order.

Algorithm Walkthrough

Let's take Example 1 [1, 0, 2, 0, 3, 0, 4]:

Start with lastNonZeroIndex = 0 and i = 0.
Iterate through the array:
- At i = 0, element 1 is non-zero, swap it with itself, and increment lastNonZeroIndex to 1.
- At i = 1, element 0 is zero, continue.
- At i = 2, element 2 is non-zero, swap it with the first 0 (at index lastNonZeroIndex, which is 1), lastNonZeroIndex becomes 2.
- At i = 3, element 0 is zero, continue.
- At i = 4, element 3 is non-zero, swap it with the 0 (at index lastNonZeroIndex, which is 2), lastNonZeroIndex becomes 3.
- At i = 5, element 0 is zero, continue.
- At i = 6, element 4 is non-zero, swap it with the 0 (at index lastNonZeroIndex, which is 3), lastNonZeroIndex becomes 4.
Resulting array after completion: [1, 2, 3, 4, 0, 0, 0].

Code

java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Solution {

  // Method to move zeroes to the end
  public List<Integer> moveZeroes(List<Integer> nums) {
    int lastNonZeroIndex = 0; // Tracks the position to place the next non-zero element

    // Iterate over the array
    for (int i = 0; i < nums.size(); i++) {
      // If the current element is non-zero
      if (nums.get(i) != 0) {
        // Swap the current element with the element at lastNonZeroIndex
        Collections.swap(nums, i, lastNonZeroIndex++);
      }
    }
    return nums;
  }

  // Main method to test the solution
  public static void main(String[] args) {
    Solution solution = new Solution();

    // Test with different examples
    // Example 1
    List<Integer> example1 = new ArrayList<>(List.of(1, 0, 2, 0, 3, 0, 4));
    System.out.println("Example 1: " + solution.moveZeroes(example1));

    // Example 2
    List<Integer> example2 = new ArrayList<>(List.of(0, 0, 0, 10, 20));
    System.out.println("Example 2: " + solution.moveZeroes(example2));

    // Example 3
    List<Integer> example3 = new ArrayList<>(List.of(5, 1, 0, 2, 0));
    System.out.println("Example 3: " + solution.moveZeroes(example3));
  }
}

Complexity Analysis

Time Complexity: O(n), where n is the length of the array, as We iterate through the array once.
Space Complexity: O(1), as the rearrangement is done in-place without using extra space.

🎯 STRICT STANDOUT — Solution Move Zeroes

1. Why / judgment

Pointer w is next write slot for a nonzero. Scan i=0..n−1: if nums[i]≠0, write to nums[w] (swap or assign) and w++. Then assign zeros on [w,n). Stability: nonzeros are written in the order discovered.

2. Big-O derivation (K11)

Pass1: O(n). Pass2 fill: O(n−w). Total Θ(n). Extra memory Θ(1).
Trace [1,0,2,0,3,0,4]:
  w writes 1,2,3,4 → array [1,2,3,4,3,0,4] mid-state if assign-with-late-zero-fill
  then zero-fill → [1,2,3,4,0,0,0] ✓
Swap variant keeps zeros bubbling right without second fill.

3. Pattern + when-NOT (K12)

Name: READ/WRITE TWO POINTERS (STABLE COMPACT)

Recognition: in-place compact nonzeros then pad zeros.

When-NOT: Need relative order of zeros too (only move one zero) → different. Linked list → pointer rewiring, not index writes.

4. Edge hand-run (K13)

[] no-op.
[0,0,0] stays.
[4,2,1] stays.
[0,1] → [1,0].

5. Interviewer follow-ups (model answers)

Q1. Assign vs swap?
A: Assign+fill does more writes when many nonzeros; swap does one swap per nonzero that is out of place.

Q2. Is this Dutch National Flag?
A: DNF is 3-way; here only 2 categories (zero vs nonzero) with order constraint on nonzeros.

Q3. Complexity if most are zeros?
A: Still Θ(n) — must scan all.

6. Short drills

Drill: implement swap-only and assign+fill both.
Drill: prove nonzeros retain order by induction on write count.

🧩 Pattern · Two Pointers

Recognize it: A sorted array where you need a pair/triplet or an in-place partition → walk two indices inward.

▶ Visualize this problem (step it, predict each fork)

⛶ Open this problem debugger in explore mode

🤖 Don't fully get this? Learn it with Claude

Stuck on Move Zeroes? Open Claude, copy a block below, and it'll teach you this exact concept — visually and interactively.

🪜 Hint ladder (no spoilers)

Progressively stronger hints — you still solve it.

I'm working on the problem **Move Zeroes** (DSA). Give me a HINT LADDER: start with the tiniest nudge, then wait. Only reveal the next, stronger hint when I ask. Do NOT show the full solution unless I type 'show solution'. Keep me doing the thinking. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

🎨 Explain the approach visually

See the technique, not just code.

Explain the optimal approach to **Move Zeroes** with a VISUAL walkthrough: trace it on a small concrete example using ASCII art / a step-by-step diagram, narrate what changes each step, then give time & space complexity with a one-line derivation. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

🔍 Review my solution

Catch bugs, edge cases, sub-optimality.

I'll paste my solution to **Move Zeroes**. Review it for correctness, missed edge cases, and time/space complexity, then coach me toward the optimal — don't just rewrite it. Ask me to paste my code now. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

🔁 Drill the pattern

Lock in recognition with look-alikes.

Give me 2 problems that use the SAME underlying pattern as **Move Zeroes**. For each, let me attempt first, then review my answer and name the trigger signal that reveals the pattern. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

📝 My notes

← Valid Perfect Square Buy Two Chocolates →