Move Zeroes
Last Updated: February 6, 2026
Problem Description
Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
Note that you must do this in-place without making a copy of the array.
Example 1:
Example 2:
Constraints:
- 1 <= nums.length <= 104
- -231 <= nums[i] <= 231 - 1
Follow up: Could you minimize the total number of operations done?
Solve it on LeetCode
Understanding the Problem
At first glance, this problem seems trivial: just find the zeros and move them to the end. But there are several constraints that make it interesting:
- In-place requirement: We cannot create a new array and copy elements over. We must modify the original array.
- Maintain relative order: The non-zero elements must appear in the same order they originally had. We cannot just swap zeros with non-zeros from the end, as that would disrupt the order.
- Minimize operations (follow-up): The optimal solution should avoid unnecessary writes to the array.
Let's visualize what we need to achieve:
The non-zero elements [1, 3, 12] maintain their relative order. The zeros have been pushed to the end.
A key observation is that we need to "shift" all non-zero elements to the front of the array. Once all non-zeros are in their correct positions at the front, whatever remains at the back will naturally be zeros.
Approaches
1. Brute Force with Extra Space
Intuition
The most intuitive approach is to create a temporary array, copy all non-zero elements first, then fill the remaining positions with zeros. While this violates the in-place constraint, it helps us understand the core logic before optimizing.
Algorithm
- Create a temporary array of the same size
- Iterate through the original array and copy all non-zero elements to the temp array
- Fill the remaining positions in temp array with zeros
- Copy the temp array back to the original array
Code
- Time Complexity: O(n), where n is the length of the array.
- Space Complexity: O(n), due to the use of additional array.
Example Walkthrough:
Input:
After the first pass (collect non-zeroes into result):
The second pass fills the remaining positions with zero (they may already be zero, but that’s fine):
Finally, we copy result back into nums:
This approach works correctly but uses extra space. Let's improve it.
2. Two-Pass In-Place Solution
Intuition
We can achieve an in-place solution by breaking the problem into two phases:
- First pass: Move all non-zero elements to the front, keeping track of where to place the next non-zero element.
- Second pass: Fill all remaining positions with zeros.
Think of it like compacting a file system: first, move all the "used" blocks to the front, then mark the rest as "free" (zeros).
Algorithm
- Initialize a pointer
writePosat 0 to track where the next non-zero element should go - Iterate through the array:
- When we find a non-zero element, place it at
writePosand incrementwritePos - After the first pass,
writePostells us where the zeros should start - Fill all positions from
writePosto the end with zeros
Code:
- Time Complexity: O(n), where n is the length of the array.
- Space Complexity: O(1), since we are modifying the array in place without using additional storage.
Example Walkthrough:
Input:
After first pass:
After second pass:
3. Optimal Two-Pointer with Swapping
Intuition
We can fine-tune our previous two-pointer approach by swapping in place.
Maintain two indices:
- writePos points to the next position where a non-zero should live.
- readPos scans the array left to right.
Whenever nums[readPos] is non-zero, swap it with nums[writePos] (only if readPos != writePos) and advance writePos. This compacts non-zeros in a single pass and leaves zeros behind naturally.
Code
- Time Complexity: O(n), as the array is traversed once.
- Space Complexity: O(1), no additional data structures are used.