Question

我需要编写一个函数来排序只有1和0的列表，我需要使用递归。我编写了一个函数，在没有递归的情况下对其进行排序（修改后的计数排序，其中包含限制以使其仅包含1和0）。有没有办法用递归重写我的解决方案？或者使用递归的这个问题的任何解决方案（可能是修改后的快速排序）？

def counting_sort(array):
   """sorting only ones and zeros"""
   count = [0] * 2               

   for a in array:
    count[a] += 1            
   i = 0
   for a in range(2):            
     for x in range(count[a]): 
        array[i] = a
        i += 1
   return array

Answer 1

这样做。它可能不是最优雅的，但它简单易行：

def binSort(array):
    if len(array) == 0:
        return []
    if array[0] == 0:
        return [0] + binSort(array[1:])
    return binSort(array[1:]) + [1]

它查看列表中的第一个元素，将零置于开头，将1置于末尾，然后移至列表的其余部分。如果您有疑问，我很乐意回答。

Answer 2

这在O（n）时间到位：

def sort(list, fromIndex, toIndex):
    if fromIndex == toIndex:
        return list
    if list[fromIndex] == 0:
        return sort(list, fromIndex + 1, toIndex)
    else:
        list[fromIndex] = list[toIndex]
        list[toIndex] = 1
        return sort(list, fromIndex, toIndex - 1)

unsortedList = [0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1]
print sort(unsortedList, 0, len(unsortedList) - 1)

输出结果为：

[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

编辑：将最小和最大变量名称更改为fromIndex和toIndex。

Answer 3

我无法抗拒用Python iterator fu尝试这个的诱惑。以下是递归的，并产生一个惰性序列：

from itertools import chain

def zero(): yield 0
def one(): yield 1

def sort01(items):
    if not callable(getattr(items, 'next', None)):
        items = iter(items)
    try:
        if items.next() == 0:
            return chain(zero(), sort01(items))
        else:
            return chain(sort01(items), one())
    except StopIteration:
        return tuple()

以下是演示：

>>> print list(sort01([0, 1, 1, 0, 0, 0, 0, 1]))
>>> [0, 0, 0, 0, 0, 1, 1, 1]

Answer 4

我认为你可以这样做，它是线性的并且可以在其中进行排序。基本上它是两个指针，一个从头开始，显示0的结束，从终点开始并显示1的开始位置。

def mysort(a, i=None, j=None):
    if not i: i = 0
    if not j: j = len(a) - 1
    if i >= j: return
    if a[i] == 1:
        a[j], a[i] = 1, a[j]
        mysort(a, i, j - 1)
    else:
        mysort(a, i + 1, j)

这是追踪：

>>> a = [1, 1, 0, 1, 0]
>>> mysort(a)
 i           j
[1, 1, 0, 1, 0]

 i        j 
[0, 1, 0, 1, 1]

    i     j
[0, 1, 0, 1, 1]

    i  j
[0, 1, 0, 1, 1]

       i
[0, 0, 1, 1, 1]

Answer 5

这不是特别快，但它是一行：

sorted_list = [i for i in original_list if not i] + [i for i in original_list if i]

Answer 6

def sort(arr):
    leftside = []
    rightside = []
    for elem in arr:
        leftside.append(elem) if elem == 0 else rightside.append(elem)

    return leftside + rightside


mylist = [0, 1, 0, 1, 0]

print sort(mylist)

现在，如果它不只是一个零，那么你的代码将开始看起来像带有左侧和右侧的快速排序，可以递归排序。但由于它只有1和0，我认为它看起来就像那样。

Answer 7

这是一个简单的代码，比此页中的任何其他代码都简单，此行是line = map（int，input（“”）。split（））），将输入内容换成一行，并分成列表和映射所有要转换为整数的元素

list = sorted（line）这是对整数元素列表进行排序

n=input() #size of an array
line=map(int,input("").split()) #elements of the list
list=sorted(line) #sorting the list
print (*list) #To print elements with space use *list eg:- 0 0 1 1 1 1

使用递归对仅包含0和1的列表进行排序

7 个答案: