从最小到最大排序

Question

I would like to sort several points from smallest to biggest however. I will wish to get this result :

Drogba 2 pts
Owen 4 pts 
Henry 6 pts

However, my ranking seems to be reversed for now :-(

Henry 6 pts 
Owen 4 pts 
Drogba 2 pts

I think my problem is with my function Bubblesort ?

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

In your code:

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

that checks if it is greater. You need to swap it if the next one is less, not greater.

Change that to:

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

Answer 2

A bunch of issues:

• def Bubblesort - PEP8 says function names should be lowercase, ie def bubblesort

• You are storing your data as a bunch of parallel lists; this makes it harder to work on and think about (and sort!). You should transpose your data so that instead of having a list of names, a list of points, a list of goals you have a list of players, each of whom has a name, points, goals.

• def bubblesort(name, goal1, point): - should look like def bubblesort(items) because bubblesort does not need to know that it is getting names and goals and points and sorting on goals (specializing it that way keeps you from reusing the function later to sort other things). All it needs to know is that it is getting a list of items and that it can compare pairs of items using > , ie Item.__gt__ is defined.

• Instead of using the default "native" sort order, Python sort functions usually let you pass an optional key function which allows you to tell it what to sort on - that is, sort on key(items[i]) > key(items[j]) instead of items[i] > items[j] . This is often more efficient and/or convenient than reshuffling your data to get the sort order you want.

• for i in range(len(name)-1): - you are iterating more than needed. After each pass, the highest value in the remaining list gets pushed to the top (hence "bubble" sort, values rise to the top of the list like bubbles). You don't need to look at those top values again because you already know they are higher than any of the remaining values; after the nth pass, you can ignore the last n values.

• actually, the situation is a bit better than that; you will often find runs of values which are already in sorted order. If you keep track of the highest index that actually got swapped, you don't need to go beyond that on your next pass.

So your sort function becomes

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

You may not be sure that this is actually correct, so let's test it:

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

Now the rest of your code becomes

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 produces

Drogba      2 pts
Owen        4 pts
Henry       6 pts