常用的六大排序算法介绍与python实现

一. 冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现：

def bubble_sort(li):
    for i in range(len(li)-1):#第i趟
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]

改进版：

判断第i趟结束后有没有发生位置交换，如果没有，表示数组已经排好序，不再需要进行下一趟。

def bubble_sort1(li):
    for i in range(len(li)-1):
        change = 0
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                change = 1
        if not change:
            return

 二. 选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def select_sort(li):
    for i in range(len(li)):    #i是第几趟
        min_loc = i
        for j in range(i+1,len(li)):
            if li[j]<li[min_loc]:
                min_loc = j    #找到当前无序区最小值下标
        if min_loc!=i:
            li[min_loc], li[i] = li[i], li[min_loc]

三. 插入排序

插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。

def insert_sort(li):
    for i in range(1,len(li)):    #i是摸到的牌的下标
        j = i-1    #j是手里最后一张牌的下标
        tem = li[i]
        while j>=0 and li[j]>tem:    #找插入位置
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tem

四. 快速排序

取一个元素p（第一个元素），使元素p归位，列表被元素p分为两部分，左边都比p小，右边都比p大。递归完成排序

def partition(li, left, right):    #归位函数
    tem = li[left]
    while left<right:
        while left<right and li[right]>tem:    #从右边找比tem小的数
            right -= 1    #往左走一步
        li[left] = li[right]    #把右边的值填到左边的空位
        while left<right and li[left]<tem:    #从左边找比tem大的数
            left += 1
        li[right] = li[left]
    li[left] = tem    #把tem归位
    return left

def quick_sort(li, left, right):
    if left<right:    #至少两个元素
        mid = partition(li, left, right)
        quick_sort(li, left, mid-1)
        quick_sort(li, mid+1, right)

五. 堆排序

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

def sift(li, low, high):
    i = low
    j = 2*i+1
    tmp = li[low] #存堆顶元素
    while j<=high: #只要j位置有数
        if j+1<=high and li[j+1]>li[j]: #取孩子节点种大的数
            j = j+1
        if li[j]>tmp:
            li[i] = li[j]
            i = j # 往下看一层
            j = 2*i+1
        else: #tmp更大，把tmp放到i位置
            break
    li[i] = tmp #把tmp放到叶子节点

def heap_sort(li):
    n = len(li)
    for i in range(n//2-1, -1, -1):#i表示建堆的时候调整部分的根的下标
        sift(li, i, n-1)
    #建堆完成
    for i in range(n-1, -1, -1):#i指向当前堆的最后一个元素
        li[0], li[i] = li[i], li[0]
        sift(li, 0, i-1)#i-1是新的high

六. 归并排序

归并排序是用分治思想，分治模式在每一层递归上有三个步骤：

• 分解（Divide）：将n个元素分成个含n/2个元素的子序列。
• 解决（Conquer）：用合并排序法对两个子序列递归的排序。
• 合并（Combine）：合并两个已排序的子序列已得到排序结果。

def merge(li, low, mid, high):
    i = low
    j = mid+1
    tmp = []
    while i<=mid and j<=high:#只要两边都有数
        if li[i]<li[j]:
            tmp.append(li[i])
            i += 1
        else:
            tmp.append(li[j])
            j += 1
    #执行完之后肯定有一边没数了
    while i<=mid:
        tmp.append(li[i])
        i += 1
    while j<=high:
        tmp.append(li[j])
        j += 1
    li[low:high+1] = tmp

def merge_sort(li, low, high):
    if low<high:#至少有两个元素，递归
        mid = (low+high)//2
        merge_sort(li, low, mid)
        merge_sort(li, mid+1, high)
        merge(li, low, mid, high)