订购没有内置排序的数字列表，最小值，最大值 function

Question

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

如果我有： [-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) （即所有数字都在新列表中）并且在不使用内置的最大、最小、排序函数的情况下对所有内容进行排序？ 我也不确定是否有必要创建一个新列表。

Answer 1

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

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)

#添加括号

Answer 2

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]

Answer 3

这严格遵循您不使用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 是一种非常有趣的排序算法，因为它可以让您“排序”一个无限的流，即您可以快速获取当前最小的项目，还可以有效地将新项目添加到要排序的数据中。

Answer 4

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

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

Answer 5

这行得通！

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

Answer 6

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

Answer 7

这是一个不是很有效的排序算法:)

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

Answer 8

尝试排序列表，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]

Answer 9

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)

Answer 10

# 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 ]

Answer 11

我的方法——

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

Answer 12

解决方案

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)

Answer 13

这是一个更易读的就地插入排序算法示例。

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

Answer 14

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

Answer 15

您可以使用 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])`

Answer 16

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)

Answer 17

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

Answer 18

由于复杂性无关紧要，我向您介绍... 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)
)

Answer 19

这是未排序的列表，我们想要的是 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是为了避免缩进错误，这样做你就会明白。

Answer 20

您可以使用迭代方法与递归函数一一进行比较。 如果要降序，则按升序排列结果，然后将条件从if l[i]>l[i+1]更改为if l[i]<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))

Answer 21

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)

Answer 22

将此与 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)```

Answer 23

l = [1, 12, 109, 2, 0, 3, 2, 90, 632, 23, 55]
for i in range(len(l)):
    for j in range(i+1, len(l)):
        if l[i] > l[j]:
            temp = l[i]
            l[i] = l[j]
            l[j] = temp
print(l)

Answer 24

nums = [2,1,-6,4,-8,-6,44,-65,5,8,3,7]
tmp = []
def get_index(val:int):
    for i in range(0,len(tmp)):
        if tmp[i] > val:
            return i
        else:
            continue
    return -1

for one_num in nums:
    print(one_num, tmp)
    if len(tmp) == 0:
        tmp.append(one_num)
    else: 
        if one_num > tmp[-1]:
            tmp.append(one_num)
        else:
            tmp.insert(get_index(one_num),one_num)
print(tmp)

Answer 25

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

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

也许像这样？

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

您可能会尝试使用单独的列表进行选择排序。 有关该排序算法的更多信息，请参阅 Wikipedia 文章，您将了解它如何与单个列表一起工作，以及它的效率如何（剧透：它不是）。

Answer 26

我们可以通过将列表保存在集合中来对列表进行排序，因为集合给出 output 作为唯一数字，它也是按升序排列的。

Answer 27

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