将零移到列表末尾

Question

I am working on moving all zeroes to end of list. .. is this approach bad and computationally expensive?

a = [1, 2, 0, 0, 0, 3, 6]
temp = []
zeros = []

for i in range(len(a)):
    if a[i] !=0:
        temp.append(a[i])
    else:
        zeros.append(a[i])

print(temp+zeros)

My Program works but not sure if this is a good approach?

Answer 1

A sorted solution that avoids changing the order of the other elements is:

from operator import not_

sorted(a, key=not_)

or without an import:

sorted(a, key=lambda x: not x)  # Or x == 0 for specific numeric test

By making the key a simple boolean, sorted splits it into things that are truthy followed by things that are falsy, and since it's a stable sort, the order of things within each category is the same as the original input.

Answer 2

This looks like a list. Could you just use sort?

a = [1, 2, 0, 0, 0, 3, 6]
a.sort(reverse=True)
a

[6, 3, 2, 1, 0, 0, 0]

Answer 3

To move all the zeroes to the end of the list while preserving the order of all the elements in one traversal, we can keep the count of all the non-zero elements from the beginning and swap it with the next element when a non-zero element is encountered after zeroes. This can be explained as:

arr = [18, 0, 4, 0, 0, 6]
count = 0
for i in range(len(arr):
    if arr[i] != 0:
        arr[i], arr[count] = arr[count], arr[i]
        count += 1

How the loop works:

when i = 0, arr[i] will be 18, so according to the code it will swap with itself, which doesn't make a difference, and count will be incremented by one. When i=1, it will have no affect as till now the list we have traversed is what we want(zero in the end). When i=4, arr[i]= 4 and arr[count(1)]= 0, so we swap them leaving the list as[18, 4, 0, 0, 0, 6] and count becomes 2 signifying two non-zero elements in the beginning. And then the loop continues.

Answer 4

Nothing wrong with your approach, really depends on how you want to store the resulting values. Here is a way to do it using list.extend() and list.count() that preserves order of the non-zero elements and results in a single list.

a = [1, 2, 0, 0, 0, 3, 6]

result = [n for n in a if n != 0]
result.extend([0] * a.count(0))
print(result)
# [1, 2, 3, 6, 0, 0, 0]

Answer 5

There's nothing wrong with your solution, and you should always pick a solution you understand over a 'clever' one you don't if you have to look after it.

Here's an alternative which never makes a new list and only passes through the list once. It will also preserve the order of the items. If that's not necessary the reverse sort solution is miles better.

def zeros_to_the_back(values):
    zeros = 0
    for value in values:
        if value == 0:
            zeros += 1
        else:
            yield value

    yield from (0 for _ in range(zeros))

print(list(
    zeros_to_the_back([1, 2, 0, 0, 0, 3, 6])
))

# [1, 2, 3, 6, 0, 0, 0]

This works using a generator which spits out answers one at a time. If we spot a good value we return it immediately, otherwise we just count the zeros and then return a bunch of them at the end.

yield from is Python 3 specific, so if you are using 2, just can replace this with a loop yielding zero over and over.

Answer 6

You can try this

a = [1, 2, 0, 0, 0, 3, 6]
x=[i for i in a if i!=0]
y=[i for i in a if i==0]
x.extend(y)
print(x)

Answer 7

Numpy solution that preserves the order

import numpy as np

a = np.asarray([1, 2, 0, 0, 0, 3, 6])
# mask is a boolean array that is True where a is equal to 0
mask = (a == 0)
# Take the subset of the array that are zeros
zeros = a[mask]
# Take the subset of the array that are NOT zeros
temp = a[~mask]
# Join the arrays
joint_array = np.concatenate([temp, zeros])

Answer 8

I tried using sorted, which is similar to sort().

a = [1, 2, 0, 0, 0, 3, 6]
sorted(a,reverse=True)

ans:
[6, 3, 2, 1, 0, 0, 0]

Answer 9

from typing import List
def move(A:List[int]):
    j=0 # track of nonzero elements
    k=-1 # track of zeroes
    size=len(A)
    for i in range(size):
        if A[i]!=0:
            A[j]=A[i]
            j+=1
        elif A[i]==0:
            A[k]=0
            k-=1

since we have to keep the relative order. when you see nonzero element, place that nonzero into the index of jth.

first_nonzero=A[0]  # j=0
second_nonzero=A[1] # j=1
third_nonzero=A[2]  # j=2

With k we keep track of 0 elements. In python A[-1] refers to the last element of the array.

first_zero=A[-1]  # k=-1
second_zero=A[-2] # k=-2
third_zero= A[-3] # k=-3

Answer 10

a = [4,6,0,6,0,7,0]
a = filter (lambda x : x!= 0, a) + [0]*a.count(0)
[4, 6, 6, 7, 0, 0, 0]

Answer 11

You can try my solution if you like

class Solution:
def moveZeroes(self, nums: List[int]) -> None:
    
    for num in nums:
        if num == 0:
            nums.remove(num)
            nums.append(num)

I have tried this code in leetcode & my submission got accepted using above code.