Python实现常见排序算法

虽然Python内部有sorted（）函数可以很方便的一句话实现列表以及元组的排序，但是为了更深入的理解算法，以及数据结构，寒舟在这里用Python实现了六个常用的排序算法，前三个算法时间复杂度为O(n^2),后面三个时间复杂度为O（logn），如有不足之处，恳请斧正。

1.插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，
从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序；
首先将第一个作为已经排好序的，然后每次从后的取出插入到前面并排序

def insert_sort(list):
    for i in range(len(list)):#依次遍历整个列表，插入第i个元素
        for j in range(i):#将前i-1个元素视为已经排好序的列表，将第i个插入
            if list[i] < list[j]:#将待排序元素与有序的列表依次比较，若发现比之大的，则插入
                list.insert(j, list.pop(i))#将此元素从原列表弹出，插入到原列表新的位置
                break#如果循环结束没有插入，则证明此元素位置合适
    return list

2.冒泡排序

它重复地走访过要排序的数列，
一次比较两个元素，如果它们的顺序错误就把它们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，
也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

def bubble_sort(list):
    for i in range(len(list)):#需要冒泡所有元素，记录冒泡次数，每次冒泡拍好一个元素
        for j in range(len(list)-i-1):#对未排序元素进行冒泡
            if list[j]>list[j+1]:#如果元素更大
                list[j],list[j+1]=list[j+1],list[j]#交换位置，放到后面
    return list

3.选择排序

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

def selection_sort(list):
	finish=[]#排好序的列表
    while list:#当列表不为空时
        k=0#记录每次循环最小值的位置
        for i in range(1,len(list)):#找到现存无序列表中的最小值
            if list[k]>list[i]:
                k=i#更新最小值位置
        finish.append(list.pop(k))#将最小值弹出并将加入有序列表
    return finish

4.希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；
随着增量逐渐减少，每组包含的关键词越来越多，
当增量减至1时，整个文件恰被分成一组，算法便终止
（理解下面代码段时，推荐从i=0，代入代码，配合画图理解）

def shell_sort(list):
	gap=len(list)#初始增量长度，设为表长
    while gap>1:#当增量为1时，退出排序
        gap//=2#对增量减半
        for i in range(gap,len(list)):#对分好的每一组进行插入排序,原数组分为了gap组，开头留有gap个元素
            for j in range(i%gap,i,gap):#对前i个元素在每一组内进行排序，每组内数据的间隔是增量gap
                if list[j]>list[i]:#如果大小顺序不对，则进行交换，保证list[i]为每一组内的最大元素
                    list[j],list[i]=list[i],list[j]
    return list

5.归并排序

归并排序是采用分治法（Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；
即先使每个子序列有序，再使子序列段间有序。
若将两个有序表合并成一个有序表，称为二路归并。

def merge_sort(list):
	if len(list)<2: return list#将单个元素返回用于合并列表
    mid=len(list)//2
    left=list[0:mid]#左列表
    right=list[mid:]#右列表
    return merge(merge_sort(left),merge_sort(right))
    #将左右列表分治后得到合并的有序列表返回到上一层进行合并

def merge(left,right):
    """
    归并排序之将两个有序列表合并成一个列表
    :param left: 左有序列表
    :param right: 右有序列表
    :return: 合并好的有序列表
    """
    finish=[]#合并好的有序列表
    while left or right:#两个有序列表至少一个不为空时
        if left and right:#两个有序列表均不为空时
            if left[0]<right[0]:#左列表元素较小
                finish.append(left.pop(0))
            else:#右列表元素较小或相等
                finish.append(right.pop(0))
        elif left and not right:#右列表空
            finish +=left
            break
        elif not left and right:#左列表空
            finish +=right
            break
    return finish#将合并好的列表返回

6.快速排序

快速排序本质上也是分治法的应用，
挑选一个基准值，将数组中比此基准值大的放在右侧，
比基准值小的放在列表左侧，
然后对此列表的左侧和右侧递归的使用上述步骤，最终得到一个有序的列表。

（1）方法一：挖坑填空

此方法相当于使用了指针的思想，比较繁琐，但是空间复杂度较低

def quick_sort(list):
	return qsort(list, 0, len(list) - 1)
    #分别为待排序列表，起始位置，以及结束位置

def qsort(list, start, end):
    if start < end:
        left = start
        right = end
        key = list[start]#首先取出一个基准值
    else:
        return list#证明已经到达最小，返回列表即可
    while left < right:#如果左右的端元素没有碰面，证明一轮排序还没有结束
        while left < right and list[right] >= key:#先从尾部与基准值比较
            right -= 1#则将右侧指针左移
        if left < right:
            # 说明打破while循环的原因是list[right] <= key
            #避免上个循环内破坏外层while循环，添加此if
            list[left] = list[right]
            #将右侧值赋予左侧，左侧初始值已经付给key担任基准值，不用担心数据丢失
            left += 1#左侧右移
        while left < right and list[left] < key:#从头部与基准值比较
            left += 1#左侧右移
        if left < right:
            # 避免上个循环内破坏外层while循环，添加此if
            # 说明打破while循环的原因是list[left] >= key
            list[right] = list[left]#左侧值赋予右侧指针
            right -= 1#右侧值左移
    list[left] = key  # 此时，left=right，用key来填坑
    qsort(list, start, left - 1)#对左右列表使用递归使用
    qsort(list, left + 1, end)
    return list

（2）方法二

此方法代码量少，容易理解，十分Python，但是空间复杂度较高

def quickSort1(list):
	    if len(list)<2:
        return list
    left=[];right=[]#左右空数组
    key=list.pop()#基准值
    """
    考虑过写 key=list[0]，但是程序崩了，想了之后发现，
    如果选择第一个元素不弹出的话，则下面的代码会把它永远放在开头，
    则之后的递归就得不到答案
    """
    for i in list:#循环此列表进行分组
        if i>key:#大于基准值，添加到右数组
            right.append(i)
        else:#否则添加到左数组
            left.append(i)
    #对左右数组递归调用，最后合并返回
    return quickSort1(left)+[key]+quickSort1(right)

十万个数据排序时间测试：

1.排序测试函数

def testnum(n,sort):
    """
    测试排序算法时间
    :param sort: 排序算法
    :param n:排序数组长度
    :return: 排序时间
    """
    nums = list(range(n))#产生数字列表
    random.shuffle(nums)#将有序列表乱序
    start=time.time()#起始时间
    sort(nums)#进行排序
    end=time.time()#排序结束时间
    return (end-start)#返回算法排序时间

2.测试主函数

def main():
    n=20000#待排序数列长度
    print("插入排序%s条数据花费时间为：%s s" %(n,testnum(n,insert_sort)))
    print("冒泡排序%s条数据花费时间为：%s s" % (n, testnum(n, bubble_sort)))
    print("选择排序%s条数据花费时间为：%s s" % (n, testnum(n, selection_sort)))
    print("希尔排序%s条数据花费时间为：%s s" % (n, testnum(n, shell_sort)))
    print("归并排序%s条数据花费时间为：%s s" % (n, testnum(n, merge_sort)))
    print("方法一快速排序%s条数据花费时间为：%s s" % (n, testnum(n, quick_sort)))
    print("方法二快速排序%s条数据花费时间为：%s s" % (n, testnum(n, quickSort1)))

结果如下：

由于机器不同，结果可能不同

我们对表现最为优异的三位选手进行第二轮测试，
一百万数据！！！
结果如下：

可见快速排序是真的快。。。。。。

转载请注明出处！