从最小到最大排序

Question

但是我想从最小到最大排序几个点。 我都希望得到这样的结果：

Drogba 2 pts 
Owen 4 pts 
Henry 6 pts 

然而，我的排名却似乎恰恰相反，现在:-(

Henry 6 pts 
Owen 4 pts 
Drogba 2 pts 

我想我的问题是我的功能冒泡

？

def Bubblesort(name, goal1, point): 
    swap = True 
    while swap: 
     swap = False 
     for i in range(len(name)-1): 
      if goal1[i+1] > goal1[i]: 
       goal1[i], goal1[i+1] = goal1[i+1], goal1[i] 
       name[i], name[i+1] = name[i+1], name[i] 
       point[i], point[i + 1] = point[i + 1], point[i] 
       swap = True 
    return name, goal1, point 

def ranking(name, point): 
    for i in range(len(name)): 
    print(name[i], "\t" , point[i], " \t ") 

name = ["Henry", "Owen", "Drogba"] 
point = [0]*3 
goal1 = [68, 52, 46] 
gain = [6,4,2] 


name, goal1, point = Bubblesort(name, goal1, point ) 
for i in range(len(name)): 
    point[i] += gain[i] 

ranking (name, point) 

Answer 1

在您的代码：

  if goal1[i+1] > goal1[i]: 

检查它是否更大。如果下一个更小，则不需要更换。

修改成：

  if goal1[i+1] < goal1[i]: 

Answer 2

一堆问题：

• def Bubblesort - PEP8说，函数名应该是小写，即def bubblesort

• 你存储你的数据，一堆平行列表;这使得工作和思考（以及排序）变得更加困难。你应该调换你的数据，以便不要有名单列表，点数列表，目标列表你有一个球员列表，每个球员都有一个名字，积分，目标。

• def bubblesort(name, goal1, point): - 应该像def bubblesort(items)因为bubblesort并不需要知道它是越来越名称和目标，并分和目标（专业这种方式让你从后重新使用功能，其他的事情排序）排序。所有它需要知道的是，它正在获取项目列表，并且它可以使用>比较项目对，即定义了Item.__gt__。

• 不使用默认的“原生”的排序顺序，Python的排序函数通常让你通过一个可选的key功能，它允许你告诉它作为排序依据是什么 - 那就是，排序上的key(items[i]) > key(items[j])代替items[i] > items[j]。这通常比重组数据以获得您想要的排序顺序更有效率和/或方便。

• for i in range(len(name)-1): - 您正在迭代超过需要。每次通过后，剩余列表中的最高值被推到顶部（因此“泡泡”排序，值像气泡一样上升到列表顶部）。您不需要再次查看这些最高值，因为您已经知道它们高于其余任何值;在第n次通过后，您可以忽略最后的n个值。

• 实际上，情况比这好一点;您经常会发现已按排序顺序排列的值的运行。如果你跟踪实际交换的最高指数，你不需要在下一次通过时超越这个指标。

所以，你的排序功能变得

def bubblesort(items, *, key=None): 
    """ 
    Return items in sorted order 
    """ 
    # work on a copy of the list (don't destroy the original) 
    items = list(items) 
    # process key values - cache the result of key(item) 
    # so it doesn't have to be called repeatedly 
    keys = items if key is None else [key(item) for item in items] 
    # initialize the "last item to sort on the next pass" index 
    last_swap = len(items) - 1 
    # sort! 
    while last_swap: 
     ls = 0 
     for i in range(last_swap): 
      j = i + 1 
      if keys[i] > keys[j]: 
       # have to swap keys and items at the same time, 
       # because keys may be an alias for items 
       items[i], items[j], keys[i], keys[j] = items[j], items[i], keys[j], keys[i] 
       # made a swap - update the last_swap index 
       ls = i 
     last_swap = ls 
    return items 

你可能不相信，这实际上是正确的，让我们来测试一下：

from random import sample 

def test_bubblesort(tries = 1000): 
    # example key function 
    key_fn = lambda item: (item[2], item[0], item[1]) 

    for i in range(tries): 
     # create some sample data to sort 
     data = [sample("abcdefghijk", 3) for j in range(10)] 
     # no-key sort 
     assert bubblesort(data) == sorted(data), "Error: bubblesort({}) gives {}".format(data, bubblesort(data)) 
     # keyed sort 
     assert bubblesort(data, key=key_fn) == sorted(data, key=key_fn), "Error: bubblesort({}, key) gives {}".format(data, bubblesort(data, key_fn)) 

test_bubblesort() 

现在你的代码的其余部分变成

class Player: 
    def __init__(self, name, points, goals, gains): 
     self.name = name 
     self.points = points 
     self.goals = goals 
     self.gains = gains 

players = [ 
    Player("Henry", 0, 68, 6), 
    Player("Owen", 0, 52, 4), 
    Player("Drogba", 0, 46, 2) 
] 

# sort by goals 
players = bubblesort(players, key = lambda player: player.goals) 

# update points 
for player in players: 
    player.points += player.gains 

# show the result 
for player in players: 
    print("{player.name:<10s} {player.points:>2d} pts".format(player=player)) 

which which produce

Drogba  2 pts 
Owen  4 pts 
Henry  6 pts