LeetCode 283: Move Zeroes Solution in Python – A Step-by-Step Guide

What Is LeetCode 283: Move Zeroes?

In LeetCode 283: Move Zeroes, you’re given an integer array nums, and your goal is to modify it in-place so that all zeros are pushed to the end, while the non-zero elements stay in their relative order. For example, [0, 1, 0, 3, 12] becomes [1, 3, 12, 0, 0]—no new array allowed, just shuffle the existing one. This problem tests your ability to manipulate arrays efficiently, sharing a spirit with classics like LeetCode 27: Remove Element, but with a focus on preserving order and relocating zeros.

Problem Statement

• Input: An integer array nums.
• Output: The array nums, modified in-place with all zeros at the end.
• Rules: Move zeros to the end; keep non-zero elements’ relative order; no extra array.

Constraints

• nums length: 1 to 10⁴ (10,000).
• nums[i]: -2³¹ to 2³¹ - 1.

Examples

• Input: nums = [0, 1, 0, 3, 12]
• Output: [1, 3, 12, 0, 0]
• Input: nums = [0]
• Output: [0]
• Input: nums = [1, 2, 3]
• Output: [1, 2, 3]

Understanding the Problem: Sweeping the Zeros

To solve LeetCode 283: Move Zeroes in Python, we need to push all zeros to the end of nums while keeping non-zeros in their original sequence—all without a second array. For [0, 1, 0, 3, 12], we want [1, 3, 12] up front, then [0, 0] at the back. A naive idea might be to shift zeros one-by-one, but that’s slow. Instead, we’ll use: 1. Best Solution (Two-Pointer): O(n) time, O(1) space—quick and clean. 2. Alternative Solution (Bubble-Like Shifting): O(n²) time—simple but inefficient.

Let’s dive into the two-pointer solution with a beginner-friendly explanation.

Best Solution: Two-Pointer Approach

Why This Is the Best Solution

The two-pointer approach is the top pick for LeetCode 283 because it’s blazing fast—O(n) time—and uses O(1) space, making just one pass through the array (plus a quick zero-fill). It’s like using one pointer to gather non-zeros at the front and another to track where they go, then filling the rest with zeros. For beginners, it’s a neat trick that feels like magic once you see it in action!

How It Works

Picture this as sorting laundry: you’ve got a pile (the array), and you want all the “good clothes” (non-zeros) at the front of your basket, with the “empty hangers” (zeros) pushed to the back. You use one hand to find non-zeros and another to place them—then toss zeros in the leftover space. Here’s how it works, step-by-step:

• Step 1: Gather Non-Zeros:
• Use a pointer non_zero_pos to track where the next non-zero element should go (starts at 0).
• Loop through the array: when you find a non-zero, place it at non_zero_pos and increment it.

• Step 2: Fill Zeros:
• After non-zeros are in front, fill the rest of the array (from non_zero_pos to the end) with zeros.

• Step 3: Why It Works:
• Non-zeros stay in order because we copy them as we find them.
• Zeros naturally end up at the end since we only move non-zeros forward.
• In-place means we’re just rearranging within nums.

• Step 4: Result:
• Array has all non-zeros first, zeros last—no extra space needed.

It’s like herding sheep to one side and letting the empty field fill the rest!

Step-by-Step Example

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

• Initial: [0, 1, 0, 3, 12], non_zero_pos = 0.
• Pass 1 (Gather Non-Zeros):
• i=0: 0—skip.
• i=1: 1—nums[0] = 1, non_zero_pos = 1.
• i=2: 0—skip.
• i=3: 3—nums[1] = 3, non_zero_pos = 2.
• i=4: 12—nums[2] = 12, non_zero_pos = 3.
• After Pass 1: [1, 3, 12, 3, 12] (last two spots unchanged yet).
• Pass 2 (Fill Zeros):
• From non_zero_pos = 3 to end: nums[3] = 0, nums[4] = 0.
• Result: [1, 3, 12, 0, 0].

Example: nums = [0, 0, 1]

• Pass 1: i=2: 1—nums[0] = 1, non_zero_pos = 1.
• After: [1, 0, 1].
• Pass 2: nums[1] = 0, nums[2] = 0.
• Result: [1, 0, 0].

Code with Detailed Line-by-Line Explanation

Here’s the Python code, explained simply:

Copy codeclass Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        # Step 1: Pointer for next non-zero position
        non_zero_pos = 0

        # Step 2: Move all non-zeros to the front
        for i in range(len(nums)):
            if nums[i] != 0:
                nums[non_zero_pos] = nums[i]
                non_zero_pos += 1

        # Step 3: Fill the rest with zeros
        for i in range(non_zero_pos, len(nums)):
            nums[i] = 0

• Line 4: non_zero_pos starts at 0—where the first non-zero goes.
• Line 6-9: Loop through nums:
• If nums[i] isn’t zero, copy it to non_zero_pos and move the pointer up.
• Line 11-12: From non_zero_pos to the end, set each spot to 0.
• No return: Modifies nums in-place.

• Time Complexity: O(n)—one pass for non-zeros, one for zeros.
• Space Complexity: O(1)—just a pointer, no extra array.

This solution is like a swift cleanup—non-zeros first, zeros last!

Alternative Solution: Bubble-Like Shifting

Why an Alternative Approach?

The bubble-like shifting method moves zeros to the end by swapping them with the next non-zero element, like bubbling them through the array. It’s O(n²) time—slower—but super intuitive, making it a great way to grasp the problem before jumping to the optimized approach.

How It Works

Imagine pushing each zero to the right, one swap at a time, until it hits the end—like bubbles rising in water:

• Step 1: Loop through the array.
• Step 2: When you find a zero, swap it with the next element, repeating until it’s at the end or hits another zero.
• Step 3: Continue until all zeros are at the end.

It’s a slow shuffle but gets the job done!

Step-by-Step Example

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

• Initial: [0, 1, 0, 3, 12].
• i=0: 0—swap with 1: [1, 0, 0, 3, 12].
• i=1: 0—swap with 0, then 3: [1, 0, 3, 0, 12].
• i=2: 3—skip.
• i=3: 0—swap with 12: [1, 0, 3, 12, 0].
• i=1: 0—swap with 3, 12, 0: [1, 3, 0, 12, 0], then [1, 3, 12, 0, 0].
• Result: [1, 3, 12, 0, 0].

Code for Bubble-Like Shifting

Copy codeclass Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        n = len(nums)
        for i in range(n):
            if nums[i] == 0:
                # Bubble the zero to the right
                for j in range(i, n - 1):
                    if nums[j + 1] != 0 or j == n - 2:
                        nums[j], nums[j + 1] = nums[j + 1], nums[j]

• Time Complexity: O(n²)—nested loops for each zero.
• Space Complexity: O(1)—in-place swaps.

It’s a steady march, but not the fastest!

Comparing the Two Solutions

• Two-Pointer (Best):
• Pros: O(n) time, O(1) space, one pass.
• Cons: Slightly trickier to visualize.
• Bubble-Like (Alternative):
• Pros: Easy to understand, step-by-step.
• Cons: O(n²) time, too slow for big arrays.

Two-pointer wins hands down.

Additional Examples and Edge Cases

• All Zeros: [0, 0] → [0, 0].
• No Zeros: [1, 2, 3] → [1, 2, 3].
• Single Element: [0] → [0].

Both handle these perfectly.

Complexity Breakdown

• Two-Pointer: Time O(n), Space O(1).
• Bubble: Time O(n²), Space O(1).

Two-pointer is the speed king.

Key Takeaways

• Two-Pointer: Gather and fill—fast!
• Bubble: Swap and shift—slow but sure.
• In-Place: No extra space needed.
• Python Tip: Loops and swaps shine—see [Python Basics](/python/basics).

Final Thoughts: Zero In on Success

LeetCode 283: Move Zeroes in Python is a fun array challenge. The two-pointer solution zips through efficiently, while bubbling offers a gentle intro. Want more? Try LeetCode 27: Remove Element or LeetCode 88: Merge Sorted Array. Ready to sweep? Head to Solve LeetCode 283 on LeetCode and move those zeros today!