Faangprep Logo
Log inStart free
Browse curriculum

Move Zeroes

Shift every 0 in the integer array nums to the back, in place, keeping the non-zero values in their original order.

EasySolve on LeetCode

Examples

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

Non-zero elements are 1, 3, 12. They stay in that order. The 0s go to the end.

Input:nums = [0]
Output:[0]

Problem Understanding

We need to push all 0s to the right side of the array.

Constraints:

  1. In-place: You cannot copy the valid numbers to a new array. You must do it inside nums.
  2. Relative Order: If 1 comes before 3 originally, it must stay that way.
  3. Minimize Operations: Ideally O(n) time.

Algorithm Strategy

We can use the Two Pointers technique to partition the array.

  • left pointer: Tracks the position where the next non-zero element should go.
  • right pointer: Scans the array to find non-zero elements.

Logic:

  1. Iterate through the array with right.
  2. If nums[right] is non-zero, we want to place it at nums[left].
  3. Swap nums[left] and nums[right]. Then left++.
  4. If nums[right] is zero, just continue scanning (right++).

Interactive Visualization

Watch how L waits for a non-zero value, and R finds it.

Dry Run: nums = [0, 1, 0, 3, 12]

L (Write) R (Read/Val) Action Array State
0 0 (0) Ignore 0. R++ [0, 1, 0, 3, 12]
0 1 (1) Swap nums[L], nums[R]. L++ [1, 0, 0, 3, 12]
1 2 (0) Ignore 0. R++ [1, 0, 0, 3, 12]
1 3 (3) Swap nums[L], nums[R]. L++ [1, 3, 0, 0, 12]
2 4 (12) Swap nums[L], nums[R]. L++ [1, 3, 12, 0, 0]

Edge Cases & Common Mistakes

Edge Cases:

  • Empty Array: Check length == 0.
  • Single Element: No changes needed.
  • All Zeroes: Pointers scan through, no swaps.
  • No Zeroes: L and R move together, swapping element with itself (harmless).

Common Mistakes:

  • Creating a copy: Violates space constraint.
  • Overwriting without Swap: If you just write non-zeroes to left, you must remember to fill the rest with zeroes at the end. (Swap method handles this automatically).

Solution

Move Zeroes Code
1var moveZeroes = function(nums) {
2    let left = 0;
3    for (let right = 0; right < nums.length; right++) {
4        if (nums[right] !== 0) {
5            [nums[left], nums[right]] = [nums[right], nums[left]];
6            left++;
7        }
8    }
9};
Previous

Valid Triangle Number

Next

Sort Colors

The approach, step by step

  1. Start the write pointer

    Set left = 0.

  2. Read every value

    Move right from the first index to the last.

  3. Swap non-zeros forward

    When nums[right] is not 0, swap it with nums[left] and move left on.

Frequently asked questions

How do two pointers solve Move Zeroes?

A read pointer visits every index; a write pointer marks where the next non-zero value belongs. Each non-zero value is swapped into the write position and the write pointer moves on, so zeros collect at the end.

Does Move Zeroes keep the non-zero values in order?

Yes. Non-zero values are written in the same order the read pointer meets them, and the swap only moves zeros, so the relative order is preserved.

What is the time and space complexity of Move Zeroes?

O(n) time, since each index is read once, and O(1) extra space, since the array is rearranged in place.

Applying for software engineering roles? Free, no sign-up:

AI resume checker — match your resume to the job description