Move Zeroes is a classic array manipulation problem from the LeetCode 75 challenge list. It evaluates your grasp of in-place updates, the two-pointer approach, and efficient iteration techniques. While the objective—moving all zeroes to the end of the list—might appear straightforward, performing the operation in-place, without disrupting the order of non-zero elements, adds a layer of complexity.
In this blog post, we’ll break down the Move Zeroes problem in Python step-by-step. We’ll explain how the code works, outline the logic behind each operation, and help you strengthen your understanding of a frequently asked coding interview question.
Table of Contents
Problem Statement
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.
Important Conditions:
- Modify the input array in-place.
- Don’t return a new array.
- Aim for minimal operations.
What does “Move Zeroes” mean?
- All non-zero elements must retain their original order.
- All zeroes must be moved to the end.
- The modification must be done without using extra space for another array.
Examples
Input: [0, 1, 0, 3, 12]
Output: [1, 3, 12, 0, 0]
Input: [1, 0, 2, 0, 3]
Output: [1, 2, 3, 0, 0]
Python Solution – Step-by-Step Explanation
Let’s look at the optimal solution using the two-pointer technique and explain it in detail:
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
non_zero_index = 0
for i in range(len(nums)):
if nums[i] != 0:
nums[non_zero_index], nums[i] = nums[i], nums[non_zero_index]
non_zero_index += 1
for i in range(non_zero_index, len(nums)):
nums[i] = 0
Step 1: Initialize Pointer
non_zero_index = 0
- This pointer tracks the position where the next non-zero value should be placed.
- It also represents the boundary between processed non-zero values and the rest of the array.
Step 2: Traverse the Array and Swap
for i in range(len(nums)):
if nums[i] != 0:
nums[non_zero_index], nums[i] = nums[i], nums[non_zero_index]
non_zero_index += 1
- Loop through each element.
- If you find a non-zero, swap it with the element at
non_zero_index. - Move the pointer forward to prepare for the next non-zero placement.
- This effectively pushes all non-zero elements to the beginning, preserving their order.
Step 3: Fill the Remaining Positions with Zeroes
for i in range(non_zero_index, len(nums)):
nums[i] = 0
- Once all non-zero elements are at the beginning, fill the rest of the array with
0. - This finalizes the in-place transformation.
Why This Solution Works
This solution is:
- ✅ Efficient: Only makes one full pass through the array.
- ✅ In-place: Doesn’t use any extra memory.
- ✅ Stable: Maintains the order of all non-zero elements.
It’s a textbook example of applying the two-pointer technique to solve array problems with optimal space and time efficiency.
Time and Space Complexity
| Metric | Value |
|---|---|
| Time Complexity | O(n) |
| Space Complexity | O(1) – in-place |
- The function scans the array twice at most—once for placing non-zeroes and once for appending zeroes.
- No extra space is used, which is critical for performance-sensitive tasks.
Edge Cases to Consider
| Case | Output | Explanation |
|---|---|---|
[0, 0, 0] | [0, 0, 0] | All elements are zero; nothing moves. |
[1, 2, 3] | [1, 2, 3] | No zero present; original order maintained. |
[0, 1] | [1, 0] | A simple case with one zero. |
[4, 0, 5, 0, 6] | [4, 5, 6, 0, 0] | Mixed zero and non-zero elements. |
Real-World Relevance
This problem is more than just an academic exercise. Here’s how the pattern shows up in practice:
- Data Cleaning: Removing or shifting invalid/missing values in data pipelines.
- Gaming Engines: Managing player states or scores where inactive entities (represented by 0) are shifted.
- Sparse Matrix Optimization: Moving non-zero values for efficient computation.
- Real-time Systems: Reducing memory writes by modifying data structures in-place.
Conclusion
The Move Zeroes problem in Python is a fundamental coding challenge that prepares you for a wide variety of real-world and interview scenarios. It helps you master in-place operations, optimal pointer movement, and efficient list processing.
By solving this, you strengthen your command over array manipulation and gain insights into writing memory-conscious, performance-optimized code. Whether you’re preparing for technical interviews or building high-performance apps, this problem—and its solution—should be part of your core toolkit.
Related Read
Mastering the String Compression Problem in Python – LeetCode 75 Explained
Stay tuned on Vanita.ai for more deep dives into LeetCode 75 problems and real-world Python problem-solving tips.