不使用內置功能對字典排序

Question

如果我有字典：

mydict = {'a':1, 'b':4, 'c':9, 'd':3, 'e':1}

如何使用諸如sorted的內置方法按從最大到最小的值對字典進行排序？

Answer 1

這是一個實現快速排序並使用它對字典值進行排序的程序。 這是Quicksort的遞歸就地實現。

def quicksort(data, left, right):
    if left+1 >= right:
        return
    tail = left
    for i in range(left, right-1):
        if data[i] < data[right-1]:
            data[tail], data[i] = data[i], data[tail]
            tail += 1
    data[right-1], data[tail] = data[tail], data[right-1]
    quicksort(data, left, tail)
    quicksort(data, tail+1, right)

mydict = { 'a': 1, 'b': 4, 'c': 9, 'd': 3, 'e': 1 }
values = [value for key, value in mydict.items()]
quicksort(values, 0, len(values))
print(values)

上面的代碼使用范圍中的最后一個元素作為樞軸。 如果您想要更好的性能，並且願意忍受更多代碼，則可以通過選擇第一個，中間和最后一個值的中位數來選擇數據透視元素。

def quicksort(data, left, right):
    if left+1 >= right:
        return
    ai, bi, ci = left, (left+right)//2, right-1
    a, b, c = data[ai], data[bi], data[ci]
    if a < b:
        if c < a:
            pos = ai
        elif c < b:
            pos = ci
        else:
            pos = bi
    else:
        if c < b:
            pos = bi
        elif c < a:
            pos = ci
        else:
            pos = ai
    pivot = data[pos]
    data[pos] = data[right-1]
    tail = left
    for i in range(left, right-1):
        if data[i] < pivot:
            data[tail], data[i] = data[i], data[tail]
            tail += 1
    data[right-1], data[tail] = data[tail], pivot
    quicksort(data, left, tail)
    quicksort(data, tail+1, right)

mydict = { 'a': 1, 'b': 4, 'c': 9, 'd': 3, 'e': 1 }
values = [value for key, value in mydict.items()]
quicksort(values, 0, len(values))
print(values)

Answer 2

冒泡排序是最容易實現的：

def order(x, y):    
    if x[1] < y[1]:
        return x, y
    else:
        return y, x

def bubble(mydict):
    d_items = mydict.items()
    for j in range(len(d_items) - 1):
        for i in range(len(d_items) - 1):
            d_items[i], d_items[i+1] = order(d_items[i], d_items[i+1])
    return d_items


mydict = {'a':1, 'b':4, 'c':9, 'd':3, 'e':1}
sorted_tuples = bubble(mydict)
print sorted_tuples  # prints [('a', 1), ('e', 1), ('d', 3), ('b', 4), ('c', 9)]

免責聲明 ：自從我現在就此發表第二條評論以來，SO成員似乎對泡沫排序感到不安。 我個人對使用冒泡排序沒有任何支持或反對。 就是說，值得一提的是，冒泡排序是一種效率低下的排序算法，其運行時復雜度為O(n^2) 。

Answer 3

一個非常簡單的快速排序實現：

def quick(lst):
    if len(lst) < 2:
        return lst
    pivot = lst[0]
    l = quick([x for x in lst[1:] if x < pivot])
    u = quick([x for x in lst[1:] if x >= pivot])
    return l + [pivot] + u