Question

我正在尝试找到一种方法来对列表进行正确的循环排序。

到目前为止，我有这个：

def min_sorted(xs):
    Min= xs[0]
    minsorted= list()
    for x in xs:
        if x < (Min):
            Min= x
            minsorted.append(Min)
            remove_val_once(x,xs)
    return minsorted

当我使用xs=[5,3,4,2,1]进行测试时，这就是：

>>> min_sorted([5,3,4,2,1])
[3, 2, 1]

5和4发生了什么

我的minval（xs）代码：

def minval(xs):
min_= xs[0]
for x in xs[1:]:
    if x < min_:
        min_=x      
return min_

我的remove_val_once代码：

def remove_val_once(val,xs):
    for i in range(len(xs)):
        if val==xs[i]:
            del(val)
            return True
            break
    if val!=xs[i]:
        return False

Answer 1

首先：你的算法存在根本缺陷;你不能这样排序。

您将在处理列表时跳过元素，原因有两个：

您放弃Min之前的值而不添加它。这就是您跳过5。
在迭代时，您正在更改列表。处理3时，您将其从列表中删除。循环查看列表中的第二项，但删除3会将列表从[5, 3, 4, 2, 1]更改为[5, 4, 2, 1]，然后循环继续到第三个项，现在2。您在那里跳过4。

至于为什么你的算法不起作用：想想你的算法如何处理已经开始时具有最小值的列表，如[1, 5, 4, 3, 2]。

Answer 2

你正在操作循环中的列表xs，这会使你的循环以奇怪的方式运行。我建议将xs复制到临时列表中并对其进行操作。见代码：

def min_sorted(xs):
    Min= xs[0]
    minsorted= list()
    t = xs[:]
    while t:
        Min = min(t)
        minsorted.append(Min)
        remove_val_once(t,Min)
    return minsorted

这是一个O（n ^ 2）算法，因为min函数本身是O（n），我们循环遍历原始输入列表。

remove_val_once中还有一个错误，您对del的使用是错误的。它应该是这样的：

del xs[i]

Answer 3

你的“排序”算法会丢弃5和4。你的所有代码都是xs的第一个小于xs[0]的元素，然后列表的下一个元素小于那个，然后是小于那个的下一个元素，依此类推列表的末尾;它永远不会对跳过的值做任何事情。

Answer 4

def min_sorted(values):
    result = []
    while values:
        m = min(values)
        result.append(m)
        values.remove(m)
    return result

Answer 5

有更简单的方法可以在不使用.sort（）的情况下进行排序。我向你介绍插入种类：

def insertionSort(unsortedList):
    # copy list
    length = len(unsortedList)
    sortedList = [None] * length
    for i in range(length):
    sortedList[i] = unsortedList[i];
    for i in range(1, length):
        j = i-1
        value = sortedList[i]
        while j >= 0 and value < sortedList[j]:
            sortedList[j+1] = sortedList[j]
            j = j-1
        sortedList[j+1] = i

Answer 6

http://en.wikipedia.org/wiki/Quicksort

Quicksort，它是n log n（非常快）。这是一个征服算法的分歧，我觉得很难记住这些步骤。

def qsort(arr):
  if len(arr) <= 1: return arr
  pivot = arr[0]
  left = []; right = []
  for i in arr[1:]:
    if arr[i] < pivot: left.append(i)
    else: right.append(i)
  return qsort(left) + [pivot] + qsort(right)

伪代码：

基础案例。
选择枢轴。
除了枢轴之外左右划分。
返回qsort（左）+ [pivot] + qsort（右）

Answer 7

简单，天真的冒泡排序：

import random

def bubble_sort(unsorted):
    length = len(unsorted) - 1
    sorted = False
    while not sorted:
        sorted = True
        for i in range(length):
            if unsorted[i] > unsorted[i+1]:
                sorted = False
                unsorted[i], unsorted[i+1] = unsorted[i+1], unsorted[i]

li = [random.randint(-100,100) for i in range(20)]
bubble_sort(li)
print li

不使用.sort（）排序列表

7 个答案: