python：对没有内置排序，最小值，最大值函数的数字列表进行排序

【问题标题】：python: order a list of numbers without built-in sort, min, max functionpython：对没有内置排序，最小值，最大值函数的数字列表进行排序
【发布时间】：2012-08-11 11:05:03
【问题描述】：

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

如果我有：[-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)

但这只经历了一次，我得到：

new_list = [-23]

这就是我卡住的地方。

如何在不使用内置最大、最小、排序函数的情况下继续循环直到 len(new_list) = len(data_list)（即所有数字都在新列表中）对所有内容进行排序？我也不确定是否有必要创建一个新列表。

【问题讨论】：

  • 我很好奇您的限制 - 为什么？此外，因此有些相关 - 这是家庭作业吗？
  • 是的，这是一个有趣的课程。我知道我可以使用排序功能来做到这一点，但我希望以另一种方式做到这一点。
  • 排序的方法有很多，但只有少数几种是远程高效的，即使使用好的算法也会比内置排序慢 100 倍
  • 我不认为这个练习的目的是为了提高效率，而是为了学习痛苦/漫长的道路。
  • 您正在使用一些似乎没有在任何地方定义的变量（i 和 value）。我在答案中更改了它们

标签： python sorting for-loop


【解决方案1】：

将此与 for 循环一起使用

    arr = [1, 5, 0, 0, 9, 10, 9, 3, 2, 3, 5,10]
    new_arr = []
    for index in range(len(arr)):
        index = len(new_arr) - index
        max_val = arr[index]
        for val in arr[index+1:]:
            if val >= max_val:
                max_val = val
        new_arr.append(max_val)
        arr.remove(max_val)
    print(new_arr)

在 while 循环中使用它

    arr = [1, 5, 0, 0, 9, 10, 9, 3, 2, 3, 5,10]
    new_arr = []
    while arr:
        max_val = arr[0]
        for x in arr:
            if x >= max_val:
                max_val = x
        new_arr.append(max_val)
        arr.remove(max_val)
    
    print(new_arr)

有函数，对于 ASC 使用 reverse = 1 和 -1 对于 DESC

    def custom_sorting(numbers, new_list, reverse=-1):
        for i in range(len(numbers)):
            first_num = numbers[0]
            for num in numbers:
                if num < first_num and reverse < 0:
                    first_num = num
                if num > first_num and reverse > 0:
                    first_num = num
    
            numbers.remove(first_num)
            new_list.append(first_num)
    
    
    if __name__ == "__main__":
        data = [5, 4, 2, 8, 70, 0, 0, 96, 5]
        newlist = []
        custom_sorting(data, newlist, reverse=1)
        print(newlist)```

【讨论】：

    【解决方案2】： 
    for i in range (0, len(unsorted_list)):
    for j in range (i,  len(unsorted_list)):
        if unsorted_list[i]> unsorted_list[j]:
            unsorted_list[i], unsorted_list[j] = unsorted_list[j], unsorted_list[i]

print("Sorted list: ", unsorted_list)

    输出是： 排序列表：[0, 5, 9, 10, 11, 20, 100, 100]

    时间复杂度是二次时间 - O (n^2)

    【讨论】：

      【解决方案3】：

      您可以使用迭代方法与递归函数一一进行比较。如果要降序，则按升序排列结果，然后将条件从 if l[i]&gt;l[i+1] 更改为 if l[i]&lt;l[i+1]：

      l=[2,1,3,4,3,2,1,2] 
list_len=len(l)

def fun(l):
    for i in range(list_len):
        if i<list_len-1:
            if l[i]>l[i+1]:
                l[i],l[i+1]=l[i+1],l[i]
                fun(l)
    return l
            
print(fun(l))

      【讨论】：

        【解决方案4】：

        这是未排序的列表，我们想要的是 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)

        对数组进行排序的最简单方法。 我正在使用当前的冒泡排序：它检查前 2 个位置并将最小的数字移到左边，依此类推。 “-n”in loop是为了避免缩进错误，这样做你就明白了。

        【讨论】：

          【解决方案5】：

          由于复杂性并不重要，我向您介绍...BogoSort：

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

          【讨论】：

            【解决方案6】：

            这行得通！

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

            【讨论】：

              【解决方案7】：

              将值从第一个位置交换到列表末尾，此代码循环 (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)

              【讨论】：

                【解决方案8】： 
                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)

                【讨论】：

                  【解决方案9】： 
                  # 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 ]

                  【讨论】：

                  • 虽然此代码可能会回答问题，但提供有关此代码为何和/或如何回答问题的额外上下文可提高其长期价值。
                  • 为你的逻辑添加解释。
                  【解决方案10】： 
                  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)

                  【讨论】：

                  • 虽然此代码可以解决问题，including an explanation 说明如何以及为什么解决问题将真正有助于提高您的帖子质量，并可能导致更多的赞成票。请记住，您正在为将来的读者回答问题，而不仅仅是现在提出问题的人。请编辑您的答案以添加解释并说明适用的限制和假设。
                  【解决方案11】：

                  解决方案

                  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)

                  【讨论】：

                    【解决方案12】：

                    你可以使用 min() 函数轻松做到这一点

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

                    【讨论】：

                      【解决方案13】： 
                      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]

                      【讨论】：

                        【解决方案14】：

                        尝试排序列表，char有ascii码，同样可以用来排序char列表。

                        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]

                        【讨论】：

                          【解决方案15】： 
                          def getIndexOfMaximum(list1):
    index = 0
    emptyList = []
    value = list1[0]
    c = 0
    while (c == 0):
        for cell in list1:
            index += 1
            if (cell >= value):
                value = cell
                hold = index -1
            if (len(list1) == index):
                emptyList += [value]
                del list1[hold]
                index = 0
                value = 0
                if (len(list1) == 1):
                    newList = emptyList + list1
                    del list1[index]
                    c = 1
    return newList
print(getIndexOfMaximum([2,5,8,7,44,54,23]))

#TRY THIS!!!

                          【讨论】：

                          • 欢迎来到 Stack Overflow！请编辑您的答案以包含更多信息。不建议使用纯代码和“试试这个”的答案，因为它们不包含可搜索的内容，也没有解释为什么有人应该“试试这个”。
                          【解决方案16】： 
                          def my_sort(lst):
    a = []
    for i in range(len(lst)):
        a.append(min(lst))
        lst.remove(min(lst))
    return a

def my_revers_sort(lst):#in revers!!!!!
    a = []
    for i in range(len(lst)):
        a.append(max(lst))
        lst.remove(max(lst))
    return a

                          【讨论】：

                            【解决方案17】：

                            这是一个更易读的就地 Insertion sort 算法示例。

                            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

                            【讨论】：

                              【解决方案18】：

                              我的方法-

                              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

                              【讨论】：

                              • 我认为这个问题的目的是学习一些关于排序算法的知识。这段代码效率很低：min(s) 将扫描所有元素以查找s，以及s.remove，假设它是一个数组，将花费 O(n) 来删除元素。这适用于s 中的每个元素。你最终得到一个二次排序算法。
                              • 还有一个问题，即 OP 明确表示（在标题中）订购一个列表 ... 没有 ... min ... 功能
                              【解决方案19】：

                              这是我一直在尝试的东西。（插入排序-不是最好的排序方式，但确实有效）

                              def sort(list):
    for index in range(1,len(list)):
        value = list[index]
        i = index-1
        while i>=0:
            if value < list[i]:
                list[i+1] = list[i]
                list[i] = value
                i -= 1
            else:
                break

                              【讨论】：

                                【解决方案20】：

                                这严格遵循您的要求，不使用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)))

                                我建议查看heapq.py 的 Python 库，看看它是如何工作的。 Heapsort 是一种非常有趣的排序算法，因为它可以让您对无限流进行“排序”，即您可以快速获取当前最小的项目，但也可以有效地将新项目添加到要排序的数据中。

                                【讨论】：

                                  【解决方案21】：

                                  我猜你正在尝试做这样的事情：

                                  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] >>> new_list = [ ] >>> while data_list: .. . minimum = data_list[0] ... for x in data_list: ... if x ”，第 7 行，在 中 ValueError: list.remove(x): x not in list >>>
                                  • @user1589244，确保缩进完全正确。你可以从这里复制粘贴
                                  • 我希望我有你的大脑。是的，当我第二次这样做时，看起来我用 if 语句而不是 for 语句缩进了 new_list.append 和 data_list.remove。一定是这样的。非常感谢@gnibbler。
                                  • @gnibbler：您能否解释一下“while data_list:”语句的目的？我无法弄清楚你的代码。一个解释会很棒！谢谢
                                  • @ShankarKumar，当 data_list 为空时，while data_list: 将停止循环
                                  【解决方案22】：

                                  这是一个not very efficient 排序算法:)

                                  >>> data_list = [-5, -23, 5, 0, 23, -6, 23, 67]
>>> from itertools import permutations
>>> for p in permutations(data_list):
...     if all(i<=j for i,j in zip(p,p[1:])):
...         print p
...         break
... 
(-23, -6, -5, 0, 5, 23, 23, 67)

                                  【讨论】：

                                  • 谢谢！我对 python 很陌生，intertools 和排列也是我在搜索谷歌时发现的东西，但我也不能使用。
                                  • 这种方法非常接近模因。我喜欢！
                                  【解决方案23】：

                                  我如何一直循环直到 len(new_list) = len(data_list)

                                  while len(new_list) != len(data_list):
    # ...

                                  可能是这样的？

                                  不，没有必要创建一个新列表；大多数排序算法都是通过更改列表来工作的。

                                  你可能想要做的是Selection sort 和一个单独的列表。有关该排序算法的更多信息，请参阅 Wikipedia 文章，您将了解它如何与单个列表一起工作，以及它的效率如何（剧透：它不是）。

                                  【讨论】：

                                  • 实际上，原始代码不会做任何接近选择排序的事情。它没有在列表中找到最小值，而是在列表中找到小于minimum 变量值的第一个值。
                                  • 哦，这很有帮助。但这是我的后续问题 - 我如何再次浏览列表，这样它不会给我相同的最小值？我可能必须从 data_list 中删除它？
                                  • 你必须记住你已经排序了，这也是你从改变列表中得到的。通过记住索引i 之前的所有内容都已排序，您只需要查看上面的那些元素。
                                  • @penartur 我显然读的比以前多；）改变了我的答案以反映这种信念。
                                  【解决方案24】： 
                                  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

                                  来自： http://rosettacode.org/wiki/Bubble_Sort#Python

                                  【讨论】：

                                  • 它只是随机化数组......所以而不是 shuffle 和所有只是在你的列表中传递给 tje bubble_sort 函数
                                  • bubble_sort(data_list);print data_list
                                  • 哦，你应该用什么..？只是选择？？
                                  • 好问题。从理论上讲，我想首先找到最小值，将其附加到一个新列表中，每个 # 随后是下一个最小值（通过迭代列表或可能使用 for 循环）。
                                  猜你喜欢
                                  • 2017-08-01
                                  • 1970-01-01
                                  • 2016-07-13
                                  • 1970-01-01
                                  • 2014-04-26
                                  • 2021-10-04
                                  • 2017-03-01
                                  • 1970-01-01
                                  • 2016-07-13
                                  相关资源
                                  最近更新 更多
                                  热门标签
                                  Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode