冒泡排序，選擇排序，快速排序和歸併排序

冒泡排序

原理
（1）循環遍歷列表，每次循環找出本次循環最大的元素排在後面
（2）需要使用嵌套循環實現，外層循環控制總循數，內層循環負責每層的循環比較

算法：

• 第一輪循環5次 = 循環列表的長度6 - 1，即元素之間比較次數；找出最大元素
• 第二輪循環4次 = 循環列表的長度6 - 找出的最大值個數1 - 1；依次類推。
• 第n輪循環n次 = 循環列表長度 m - 找出的最大值個數 j - 1
• n = 列表元素個數 - 1

算法實現：

# 排序的總輪數=列表元素個數 - 1
# 每輪元素互相比較的次數 = 列表元素個數 - 已經排好序的元素個數 - 1

#data_list:待排序列表
def bubble_sort(data_list):
    num = len(data_list) #列表元素個數
    for i in range(0,num -1):#排序的總輪數
        print("第{}輪：".format(i))
        for j in range(0,num-i-1):
            if data_list[j] > data_list[j+1]:#前後兩個元素比較
                data_list[j],data_list[j+1] = data_list[j+1],data_list[j]
            print(data_list)

選擇排序

原理
（1）將待排序列表看成是未排序和已排序兩部分
（2）每次從未排序列表中找出最小值放到已排序列表末尾

算法
算法實現

#data_list:待排序列表
def select_sort(data_list):
    list_len = len(data_list) #待排序元素個數
    for i in range(0,list_len-1):#控制排序比較總輪數
        tmp_min_index = i
        for j in range(i+1,list_len):
            if data_list[tmp_min_index] > data_list[j]:
                tmp_min_index = j
        if i != tmp_min_index:
            data_list[i],data_list[tmp_min_index] = data_list[tmp_min_index],data_list[i]

        print(data_list)

快速排序

原理
（1）一次排序按照一個基準值將待排序的列表分隔成兩部分，基準值左邊是比基準值小的元素，基準值右邊是比基準值大的元素
（2）按照上一步的方法對基準值左右兩部分數據分別進行快速排序

算法

算法實現

#data_list:待排序列表
def quick_sort(data_list,start,end):
    #設置遞歸結束條件
    if start >= end:
        return
    low_index = start#低位遊標
    high_index = end #高位遊標
    basic_data = data_list[start] #初始基準值
    while low_index < high_index:
        #模擬高位遊標從右向左指向的元素與基準值進行比較，比基準值大則高位遊標一直向左移動
        while low_index < high_index and data_list[high_index] >= basic_data:
            high_index -= 1
        if low_index != high_index:
            #當高位遊標指向的元素小於基準值，則移動該值到低位遊標指向的位置
            data_list[low_index] = data_list[high_index]
            low_index += 1 #低位遊標向右移動一位

        while low_index < high_index and data_list[low_index]<basic_data:
            low_index +=1
        if low_index != high_index:
            data_list[high_index] = data_list[low_index]
            high_index -= 1

    data_list[low_index] = basic_data
    #遞歸調用
    quick_sort(data_list,start,low_index-1) #對基準值左邊未排序隊列排序
    quick_sort(data_list,high_index+1,end) #對基準值右邊未排序隊列排序

歸併排序

原理
先遞歸分解序列，再排序合併序列

算法
（1）拆分到不能分爲止
（2）合併的過程中進行排序
算法排序

#data_list:待排序列表
def merge_sort(data_list):
    if len(data_list)<=1:
        return data_list
    #根據列表長度確定拆分的中間位置
    mid_index = len(data_list) // 2
    # left_list = data_list[:mid_index] #使用切片實現對列表的切分
    # right_list = data_list[mid_index:]
    left_list = merge_sort(data_list[:mid_index])
    right_list = merge_sort(data_list[mid_index:])
    return merge(left_list,right_list)

def merge(left_list,right_list):
    l_index = 0
    r_index = 0
    merge_list = []
    while l_index < len(left_list) and r_index < len(right_list):
        if left_list[l_index] < right_list[r_index]:
            merge_list.append(left_list[l_index])
            l_index += 1
        else:
            merge_list.append(right_list[r_index])
            r_index += 1

    merge_list += left_list[l_index:]
    merge_list += right_list[r_index:]
    return merge_list

排序調用輸出：

list = [28,32,14,12,53,42]
#冒泡排序
bubble_sort(list)
#選擇排序
select_sort(list)
#快速排序
quick_sort(list,0,len(list)-1)
#歸併排序
new_list = merge_sort(list)
print("--------排序結果--------")
print(new_list)