python：在没有内置排序、最小值、最大值函数的情况下对数字列表进行排序

如果我有一个每次长度都不同的列表，我想从最低到最高排序，我会怎么做

如果我有：

[-5，-23,5,0,23，-6,23,67]

我想要：

[-23，-6，-5,0,5,23,23,67]

我从以下几点开始：

data_list = [-5, -23, 5, 0, 23, -6, 23, 67]

new_list = []

minimum = data_list[0]  # arbitrary number in list 

for x in data_list: 
  if x < minimum:
    minimum = value
    new_list.append(i)

这就是我被卡住的地方

我如何继续循环，直到

len（新列表）=len（数据列表）

（即所有数字都在新列表中），所有内容都已排序，而不使用内置的max、min、sort函数？我不确定是否有必要创建一个新的列表

def bubble_sort(seq):
    """Inefficiently sort the mutable sequence (list) in place.
       seq MUST BE A MUTABLE SEQUENCE.

       As with list.sort() and random.shuffle this does NOT return 
    """
    changed = True
    while changed:
        changed = False
        for i in xrange(len(seq) - 1):
            if seq[i] > seq[i+1]:
                seq[i], seq[i+1] = seq[i+1], seq[i]
                changed = True
    return None

if __name__ == "__main__":
   """Sample usage and simple test suite"""

   from random import shuffle

   testset = range(100)
   testcase = testset[:] # make a copy
   shuffle(testcase)
   assert testcase != testset  # we've shuffled it
   bubble_sort(testcase)
   assert testcase == testset  # we've unshuffled it back into a copy

发件人：

我如何继续循环直到len（新列表）=len（数据列表）

也许是这样

不，不需要创建新列表；大多数排序算法都是通过更改列表来工作的

你可能想做的是用一个单独的列表。有关排序算法的更多信息，请参阅Wikipedia文章，您将看到它如何处理单个列表，以及它的效率（扰流板：不是）。

这里是一个排序算法：）

数据列表=[-5，-23,5,0,23，-6,23,67] >>>从itertools导入置换 >>>对于排列中的p（数据列表）：

---

... 如果所有（i我猜你是在尝试这样做：

data_list = [-5, -23, 5, 0, 23, -6, 23, 67]
new_list = []

while data_list:
    minimum = data_list[0]  # arbitrary number in list 
    for x in data_list: 
        if x < minimum:
            minimum = x
    new_list.append(minimum)
    data_list.remove(minimum)    

print new_list

data_list=[-5，-23,5,0,23，-6,23,67]
新列表=[]
而数据列表：
最小值=数据列表[0]#列表中的任意数字
对于数据列表中的x：
如果x<最小值：
最小值=x
新列表。追加（最小值）
数据列表。删除（最小值）
打印新列表

这严格遵循您的要求，不使用

sort（）

、

min（）

、

max（）

，但也使用Python最佳实践，不重新发明控制盘

data_list = [-5, -23, 5, 0, 23, -6, 23, 67]
import heapq
heapq.heapify(data_list)
new_list = []
while data_list:
    new_list.append(heapq.heappop(data_list)))

---

我建议查看Python库中的

heapq.py

，看看它是如何工作的。Heapsort是一个非常有趣的排序算法，因为它允许您对无限流进行“排序”，也就是说，您可以快速获得当前最小的项，但也可以有效地将新项添加到要排序的数据中。

以下是我一直在尝试的内容。（插入排序-不是排序的最佳方式，但确实有效）

def排序（列表）：
对于范围（1，len（list））中的索引：
值=列表[索引]
i=指数-1
当i>=0时：
如果值<列表[i]：
列表[i+1]=列表[i]
列表[i]=值
i-=1
其他：
打破

我的方法-

s = [-5, -23, 5, 0, 23, -6, 23, 67]
nl = []
for i in range(len(s)):
    a = min(s)
    nl.append(a)
    s.remove(a)

print nl

解决方案

mylist = [1, 6, 7, 8, 1, 10, 15, 9]
print(mylist)
n = len(mylist)
for i in range(n):
    for j in range(1, n-i):
        if mylist[j-1] > mylist[j]:
             (mylist[j-1], mylist[j]) = (mylist[j], mylist[j-1])
print(mylist)

---

下面是一个更具可读性的就地算法示例

a = [3, 1, 5, 2, 4]

for i in a[1:]:
    j = a.index(i)
    while j > 0 and a[j-1] > a[j]:
        a[j], a[j-1] = a[j-1], a[j]
        j = j - 1

---

试试排序列表，字符有ascii码，同样可以用来排序字符列表

aw=[1,2,2,1,1,3,5,342,345,56,2,35,436,6,576,54,76,47,658,8758,87,878]
for i in range(aw.__len__()):
    for j in range(aw.__len__()):
        if aw[i] < aw[j] :aw[i],aw[j]=aw[j],aw[i]

aw=[1,2,2,1,1,3,5342345,56,2,35436,6576,54,76,476588758,878]
对于范围内的i（aw.\u len\u（））：
对于范围内的j（aw.____;len（））：
如果aw[i]

输出：

[1, 2, 3, 11, 12, 22, 23, 25, 34, 44, 64, 122]

---

通过使用min（）函数，您可以轻松地完成此操作

#您当前的设置
数据列表=[-5，-23,5,0,23，-6,23,67]
新列表=[]
#排序函数
对于数据列表中的i：
new_list=[x代表新_list中的x，如果i>x]+[i]+[x代表新_list中的x如果i将值从第一个位置交换到列表的末尾，此代码循环（n*n-1）/2次。每次它都将较大的值从零索引推送到较大的索引

list2 = [40,-5,10,2,0,-4,-10]
for l in range(len(list2)):
    for k in range(l+1,len(list2)):
        if list2[k] < list2[l]:
            list2[k] , list2[l] = list2[l], list2[k]
print(list2)

list2=[40，-5,10,2,0，-4，-10]
对于范围内的l（len（列表2））：
对于范围（l+1，len（列表2））中的k：
如果列表2[k]<列表2[l]：
list2[k]，list2[l]=list2[l]，list2[k]
打印（列表2）
这很有效

def sorting(li):
    for i in range(len(li)):
        for j in range(len(li)):
            if li[i] < li[j]:
                li[j],li[i] = li[i],li[j]
    return li

listToSort = [22,11,23,1,100,24,3,101,2,4]
print(sorting(listToSort))

def排序（li）：
对于范围内的i（len（li））：
对于范围内的j（len（li））：
如果li[i]
既然复杂性无关紧要，我向您介绍……博戈索尔：

from random import shuffle

def is_sorted(ls):
    for idx in range(len(ls)-1):
        if x[idx] > x[idx + 1]:
          return False
    return True

def sort(ls):
    while not is_sorted(ls):
        shuffle(ls)
    return ls


ls = list(range(5))
shuffle(ls)

print(
    "Original: ",
    ls
)

print(
    "Sorted: ",
    sorted(ls)
)

这是未分类的列表，我们想要的是1234567

list = [3,1,2,5,4,7,6]

def sort(list):
    for i in range(len(list)-1):
        if list[i] > list[i+1]:
            a = list[i]
            list[i] = list[i+1]
            list[i+1] = a
        print(list)       

sort(list)

排序数组的最简单方法中的最简单方法。
Im使用当前的气泡排序，即：它检查前2个位置，并将最小的数字向左移动，依此类推。
“-n”in-loop是为了避免缩进错误，你可以通过这样做来理解它。
我很好奇你的约束条件-为什么？还有，因为这有点相关-这是家庭作业吗？是的，这是一个有趣的类。我知道我可以用排序函数来做这件事，但希望用另一种方法来做。排序的方法很多，但只有少数几种它们的效率很低，即使使用一个好的算法也比内置的sortI慢约100倍。我不认为这项练习的目的是为了提高效率，而是为了学习痛苦/漫长的过程。您使用了一些变量（
i
和
value
）这似乎没有在任何地方定义。我在回答中更改了它们。实际上，原始代码不会做任何接近选择排序的事情。它不会在列表中找到最小值，它会在列表中找到小于
最小值
变量值的第一个值。哦，这很有帮助。但我的后续问题是-如何再次遍历列表，使其不会给出相同的最小值？我可能必须将其从数据列表中删除？您必须记住您已排序的内容，这也是更改列表后得到的内容。记住索引
I
之前的所有内容都已排序，您只需查看上面的元素即可t、 @penartur我显然读得比原来多；）更改了我的答案以反映这种信念。它只是随机化数组…因此，它不是洗牌，而是将列表中的所有内容传递给tje bubble_排序函数
bubble_排序（数据列表）；打印数据列表
哦，你应该使用什么？只是选择？好问题。理论上，我想先找到最小值，将其附加到新列表中，然后将每个最小值作为下一个最小值（通过迭代
aw=[1,2,2,1,1,3,5,342,345,56,2,35,436,6,576,54,76,47,658,8758,87,878]
for i in range(aw.__len__()):
    for j in range(aw.__len__()):
        if aw[i] < aw[j] :aw[i],aw[j]=aw[j],aw[i]

l = [64, 25, 12, 22, 11, 1,2,44,3,122, 23, 34]

for i in range(len(l)):
    for j in range(i + 1, len(l)):

        if l[i] > l[j]:
           l[i], l[j] = l[j], l[i]

print l

[1, 2, 3, 11, 12, 22, 23, 25, 34, 44, 64, 122]

`def asc(a):
    b=[]
    l=len(a)
    for i in range(l):
        x=min(a)
        b.append(x)
        a.remove(x)
    return b
 print asc([2,5,8,7,44,54,23])`

data = [3, 1, 5, 2, 4]
n = len(data)
    for i in range(n):
        for j in range(1,n):
            if data[j-1] > data[j]:
                (data[j-1], data[j]) = (data[j], data[j-1])
    print(data)

# Your current setup
data_list = [-5, -23, 5, 0, 23, -6, 23, 67]
new_list  = []

# Sort function
for i in data_list:
    new_list = [ x for x in new_list if i > x ] + [i] + [ x for x in new_list if i <= x ]

n = int(input("Input list lenght: "))
lista = []
for i in range (1,n+1):
    print ("A[",i,"]=")
    ele = int(input())
    lista.append(ele)
print("The list is: ",lista)
invers = True
while invers == True:
    invers = False 
    for i in range (n-1):
        if lista[i]>lista[i+1]:
            c=lista[i+1]
            lista[i+1]=lista[i]
            lista[i]=c
            invers = True
print("The sorted list is: ",lista)

list2 = [40,-5,10,2,0,-4,-10]
for l in range(len(list2)):
    for k in range(l+1,len(list2)):
        if list2[k] < list2[l]:
            list2[k] , list2[l] = list2[l], list2[k]
print(list2)

def sorting(li):
    for i in range(len(li)):
        for j in range(len(li)):
            if li[i] < li[j]:
                li[j],li[i] = li[i],li[j]
    return li

listToSort = [22,11,23,1,100,24,3,101,2,4]
print(sorting(listToSort))

from random import shuffle

def is_sorted(ls):
    for idx in range(len(ls)-1):
        if x[idx] > x[idx + 1]:
          return False
    return True

def sort(ls):
    while not is_sorted(ls):
        shuffle(ls)
    return ls


ls = list(range(5))
shuffle(ls)

print(
    "Original: ",
    ls
)

print(
    "Sorted: ",
    sorted(ls)
)

list = [3,1,2,5,4,7,6]

def sort(list):
    for i in range(len(list)-1):
        if list[i] > list[i+1]:
            a = list[i]
            list[i] = list[i+1]
            list[i+1] = a
        print(list)       

sort(list)