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

Question

I need to write a function that sorts a list of only 1s and 0s and I need to use recursion. I wrote a function that sorts it without recursion(a modified counting sort, with restrictions put in to make it only take in ones and zeros). Is there any way to rewrite my solution using recursion? Or any solution to this problem that uses recursion(maybe a modified quicksort)?

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

This will do it. It may not be the most elegant, but it's simple and easy:

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

It looks at the first element in the list, puts zeroes at the beginning and ones at the end, and moves on to the rest of the list. If you have questions, I'd be happy to answer them.

Answer 2

This sorts in place in O(n) time:

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)

The output is:

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

EDIT: Changed the min and max variable names to fromIndex and toIndex.

Answer 3

I couldn't resist a temptation to try this with Python iterator fu. The following is recursive, and produces a lazy sequence:

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()

Here's the demo:

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

Answer 4

I think you could do it like this, it's linear and sorts inplace. Basically it's two pointers, one going from the beginning and shows where 0's end and enother going from the end and showing where 1's starts.

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)

here's the trace:

>>> 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)

Now, if it wasn't just one and zeros, then your code would begin to look like quicksort with a leftside and a rightside that gets sorted recursively. but since it's only 1 and zero, I think it would look like that.

Answer 7

This is a simple code and easy than any other in this page and this line is line=map(int,input("").split()) takeing the input in a single line and split into a list and mapping all elements to convert into integers

list=sorted(line) this ia sorting the list of integer elements

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