1.氣泡排序法

• 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該 會是最大的數。
• 針對所有的元素重複以上的步驟，除了最後一個。
• 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

#氣泡排序

def bubbling(list):
    n = len(list)
    for i in range(n-1):
        for j in range(n-1-i):
            if list[j] >= list[j+1]:
                list[j],list[j+1] = list[j+1],list[j]
    return list

list3 = [9,3,2,1,7]
# print(bubbling(list3))

#對列表中元素是字典的排序
l = [
    {'name':'xiaowang', 'age':18,'height':150},
    {'name':'xiaogang', 'age':20,'height':140},
    {'name':'xiaohong', 'age':19,'height':145},
]
def sort(l,key=None,reverse=True):  #封裝函式  函式名sort 引數：列表l ，鍵的初始值定為空，預設排序為逆序
    n = len(l)                    #獲取列表長度
    for i in range(n-1):         #遍歷列表元素  外層迴圈控制迴圈次數
        for j in range(n-1-i ):  #內層迴圈  兩兩比較（氣泡排序）
            if key == None:  # 即鍵值對不存在執行下面程式
                # 首先判斷reverse的真假
                # 這是對上面的簡寫  即：如果reverse為真執行(l[j] <l[j + 1])
                # 如果reverse為假執行(l[j]>l[j + 1])
                is_swap = (l[j] < l[j + 1]) if reverse else (l[j] > l[j + 1])

            else:  # 即key存在
                # 如果key存在執行下面命令
                # 存在鍵值對，即字典不能直接比較大小，要選取其中元素的值進行比較大小
                is_swap = (key(l[j]) < key(l[j + 1])) if reverse else (key(l[j]) > key(l[j + 1]))

                if is_swap:  # 如果is_swap存在，要交換元素的位置
                    l[j], l[j + 1] = l[j + 1], l[j]
#保持原列表不變，生成一個新列表 用到函式sorted
l1 = sorted(l,key=lambda d:d['age'] ,reverse=True)   # lambda匿名函式。
                                             # 格式：lambda 引數1，引數2、、、：表示式
                                             # 在字典中引數d為字典中的元素，表示式為元素的鍵d['age']
                        # key存在通過匿名函式使用字典中的鍵值對比較大小
for i in l1:            #遍歷新列表
 print(i)

 

2.快速排序（概念見百科）

• 通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。
• 快速排序是對氣泡排序的一種本質改進，快速排序通過一趟掃描，就能確保某個數的左邊各數都比它 小，右邊各數都比它大

def quickSort(L,low,high):
    i=low 
    j=high     
    if i>=j:         
        return L      
    key=L[i]     
    while i<j:         
        while i<j and L[j]>=key:             
            j=j-1         
        L[i]=L[j]         
        while i<j and L[i]<=key:             
            i=i+1         
        L[j]=L[i]     
    L[i]=key     
    quickSort(L,low,i-1)     
    quickSort(L,j+1,high)     
    return L 
    
li = [9,3,2,6,1,0]
print(quickSort(li,0,len(li)-1))

#寫法2（見百科）
def quickSort2(array):
    if len(array) < 2:  # 基線條件（停止遞迴的條件）
        return array
    else:  # 遞迴條件
        baseValue = array[0]  # 選擇基準值
        # 由所有小於基準值的元素組成的子陣列
        less = [m for m in array[1:] if m < baseValue]
        # 包括基準在內的同時和基準相等的元素，在上一個版本的百科當中，並沒有考慮相等元素
        equal = [w for w in array if w == baseValue]
        # 由所有大於基準值的元素組成的子陣列
        greater = [n for n in array[1:] if n > baseValue]
    return quickSort2(less) + equal + quickSort2(greater)

list = [2,3,4,1,6,3,0]
print(quickSort2(list))
 

3.插入排序（選擇排序）

• 如將第一個數分別與後面的所有數比較，不合適交換，交換後緊接著再與後面的數比較，不合適在交換，直到比較到最後一個，每次能夠確定一個最大的數

def sor(lis):
    n = len(lis)
    for i in range(n):
        for j in range(i+1,n):
            if lis[i]>lis[j]:
                lis[i],lis[j] = lis[j],lis[i]
    return lis
l = sor([2,1,4,6,3,0])

print(l)