冒泡，选择，插入，快速，归并排序

(1)冒泡排序

1、基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，

让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

'''冒泡排序'''
def bubble_sort(alist):
    n = len(alist)
    for j in range(n - 2):
        count = 0
        for i in range(n - 1 - j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i + 1],alist[i]
                count += 1
        if count == 0:
            return
if __name__ == '__main__':
    a = [3,5,2,4,1,9,6]
    print(a)
    bubble_sort(a)
    print(a)

② 选择排序

•思想：每趟从待排序的记录序列中选择关键字最小的记录放置到已排序表的最前位置，直到全部排完。 
•关键问题：在剩余的待排序记录序列中找到最小关键码记录。 
•方法： 
–直接选择排序 
–堆排序

(1)直接选择排序

1、基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置

的数交换，如此循环到倒数第二个数和最后一个数比较为止。

2、实例

'''选择排序'''
def choose_sort(alist):
    n = len(alist)
    for j in range(n - 1):
        min_index = j
        for i in range(j+1,n):
            if alist[min_index] > alist[i]:
                min_index = i
        alist[j],alist[min_index] = alist[min_index],alist[j]

if __name__ == '__main__':
    a = [3,5,2,4,1,9,6]
    print(a)
    choose_sort(a)
    print(a)

'''插入排序'''
def insert_sort(alist):
    n = len(alist)
    for j in range(1,n):
        i = j
        while i > 0:
            if alist[i] < alist[i - 1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
            i -= 1
if __name__ == '__main__':
    a = [3,5,2,4,1,9,6]
    print(a)
    insert_sort(a)
    print(a)

(2)快速排序

1、基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准

元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

2、实例

'''快速排序'''
def quack_sort(alist,first,last):
    if first >= last:
        return
    mid_vaues = alist[first]
    low = first
    high = last
    while low < high:
        while low < high and alist[high] >= mid_vaues:
            high -= 1
        alist[low] = alist[high]
        while low < high and alist[low] < mid_vaues:
            low += 1
        alist[high] = alist[low]
    #从循环退出时，low = high
    alist[low] = mid_vaues
    #对low左边进行查找
    quack_sort(alist,first,low-1)
    #对low右边进行查找
    quack_sort(alist,low+1,last)
if __name__ == '__main__':
    a = [3,5,2,4,1,9,6]
    print(a)
    quack_sort(a,0,len(a)-1)
    print(a)

④ 归并排序

1、基本思想:归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，

每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

2、实例

'''归并排序'''
def merge_sort(alist):
    n = len(alist)
    if n <= 1:
        return alist
    mid = n//2
    # left_li 采用归并算法后形成的有序的新的列表
    left_li = merge_sort(alist[:mid])
    # right_li 采用归并算法后形成的有序的新的列表
    right_li = merge_sort(alist[mid:])

    #将有序数列的子序列合并成一个新的整体
    left_pointer,right_pointer = 0,0
    result = []
    while right_pointer < len(right_li) and left_pointer < len(left_li):
        if right_li[right_pointer] < left_li[left_pointer]:
            result.append(right_li[right_pointer])
            right_pointer += 1
        else:
            result.append(left_li[left_pointer])
            left_pointer += 1
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result
if __name__ == '__main__':
    a = [3,5,2,4,1,9,6]
    print(a)
    merge_a = merge_sort(a)
    print(merge_a)