Move Zeroes

Single Number

Factorial

Move every zero to the end while preserving non-zero element order.

Reorder `nums` so every zero appears after all non-zero values while preserving the relative order of non-zero values. Return the reordered array; implementations should update the supplied array when the language supports mutation.

**Input / output**
- Input: `nums: integer[]`
- Output: the reordered integer array

**Examples**
1. `[0,1,0,3,12]` returns `[1,3,12,0,0]`.
2. `[1,2,3]` remains `[1,2,3]`.

**Constraints**
- `0 <= nums.length <= 100,000`
- `-1,000,000 <= nums[i] <= 1,000,000`

**Follow-up**
Can you use two pointers with linear time, constant auxiliary space, and the minimum necessary writes?

- Move every `0` to the end of the array.
- Preserve the relative order of all non-zero values.
- The function returns the resulting array.

Understand the Goal

- Collect all non-zero values first.
- Count how many zeroes are needed at the end.
- This is easy to understand but uses extra space.

Simple Extra-Array Approach

- Keep a pointer for where the next non-zero value should be placed.
- Scan the array from left to right.
- Every non-zero value is written to the next available position, preserving order.

Use a Write Pointer

- After all non-zero values are written, everything from the write pointer to the end should be `0`.
- This produces the same array shape without needing a second array.
- Finally, return `nums`.

Fill the Remaining Positions with Zeroes

- The solution keeps non-zero elements in their original relative order.
- Time complexity is O(n).
- Space complexity is O(1) besides the input array.