Is Move Zeroes easy or hard?

Move Zeroes is categorized as an Easy problem on LeetCode with an acceptance rate above 60%. Despite the difficulty label, it reinforces an essential interview pattern: in-place array manipulation using two pointers.

Move Zeroes Python/Java solution

In both Python and Java, the standard solution uses two pointers. Iterate through the array, move each non-zero value to the next available position, and optionally swap elements when needed. This produces an O(n) time and O(1) space implementation.

How to solve Move Zeroes in O(n)?

Maintain two pointers: one scanning the array and another tracking the position of the next non-zero element. When a non-zero value appears, move or swap it to the tracked position. This single-pass strategy processes all elements once and keeps zeroes pushed toward the end.

What is the best approach for Move Zeroes?

The optimal solution uses the two-pointer technique with O(n) time and O(1) extra space. One pointer scans the array while another tracks the position for the next non-zero element. This preserves the relative order of non-zero values and performs the transformation in-place.

Is Move Zeroes asked at Google/Amazon/Meta?

Move Zeroes is a common array manipulation problem that appears in coding interviews at companies like Amazon, Meta, and Google. It tests understanding of in-place array operations and the two-pointer pattern, both frequently used in real interview questions.

What data structure is used in Move Zeroes?

The problem operates directly on an array. The key algorithmic technique is the two-pointer method, which allows efficient in-place modification while maintaining the relative order of elements.

What is the time complexity of Move Zeroes?

The optimal approach runs in O(n) time because the array is scanned only once. Each element is processed exactly once, and swaps or writes happen at most n times. Space complexity remains O(1) since no additional data structures are required.

Description Hints 2 Solution Video 8:15

283. Move Zeroes

Easy64.3% acceptance46 companies

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:

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

Example 2:

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

Constraints:

1 <= nums.length <= 10⁴
-2³¹ <= nums[i] <= 2³¹ - 1

Follow up: Could you minimize the total number of operations done?

Asked at top 20 of 46 companies

EPAM Systems NetApp LTIMindtree Chewy Jtg Coinswitch Kuber

Infosys Wix KPMG ADP Bloomberg

TCS

+8 more

Walmart Labs Accenture Yandex Qualcomm Cognizant Josh Technology Capgemini AMD

Topics

Array Two Pointers

Hints open one at a time

Hint 1

In-place means we should not be allocating any space for extra array. But we are allowed to modify the existing array. However, as a first step, try coming up with a solution that makes use of additional space. For this problem as well, first apply the idea discussed using an additional array and the in-place solution will pop up eventually.

Hint 2

A two-pointer approach could be helpful here. The idea would be to have one pointer for iterating the array and another pointer that just works on the non-zero elements of the array.

8:15

Still stuck?Read 3 approaches, or watch a walkthrough.

Open solution