Python 排序算法

常见排序算法效率比较

冒泡排序

操作步骤：

1. 比较相邻的元素，如果第一个比第二个大(升序)，就交换他们。
2. 对每一对相邻元素作同样的工作，从开始一直到列表最后。这步做完，最后元素会是最大的数。
3. 除了最后一个的所有元素，重复上面的操作，直到遍历结束。

时间复杂度：O(n^2)

稳定性：稳定。

代码实现：

默认升序

def bubbleSort(lst):
    #
    for i in range(len(lst)):
        flag=True
        for j in range(len(lst)-i-1):
            if lst[j]>lst[j+1]:
                lst[j],lst[j+1]=lst[j+1],lst[j]
                flag=False
        #for i in range(len(lst)-1,0,-1):
        #    for j in range(i):
        if flag:
            break
    return lst

自定义排序: 根据传入的参数确定排序方式

def bubbleSort(lst,reverse=False):
    '''自定义排序方式，默认reverse=False为升序，也可以令reverse=True为降序'''
    #设置排序表达式，默认升序，判断是否大于
    exp='lst[j]>lst[j+1]'
    #当reverse=True时为降序排序，更改排序表达式，判断是否小于
    if reverse:
        exp='lst[j]<lst[j+1]'
    for i in range(len(lst)):
        flag=True
        for j in range(len(lst)-i-1):
            if eval(exp):
                lst[j],lst[j+1]=lst[j+1],lst[j]
                flag=False
        if flag:
            break
    return lst
if __name__=='__main__':
    li = [17,20,93,54,77,31,44,55,65]
    upLi=bubbleSort(li)
    print(upLi)

    downLi=bubbleSort(li,reverse=True)
    print(downLi)

选择排序

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

时间复杂度：O(n^2)

稳定性：不稳定

代码实现：

默认升序

def selectSort(lst):
    n=len(lst)
    #需要进行n-1次选择操作
    for i in range(n-1):
        #记录最小位置
        m=i
        for j in range(i+1,n):
            if lst[j]<lst[m]
                m=j
        #如果选择出来的数据不再正确的位置，进行交换
        if m!=i
            lst[i],lst[m]=lst[m],lst[i]

自定义排序方式：根据传递的参数设置排序表达式。

def selectSort(lst,reverse=False):
    '''默认为升序，当reverse=True时，为降序排序。'''
    exp='lst[j]<lst[m]'
    if reverse:
        exp='lst[j]>lst[m]'
    length=len(lst)
    for i in range(length-1):
        m=i
        for j in range(i+1,length):
            if eval(exp):
                m=j
        if m!=i:
            lst[m],lst[i]=lst[i],lst[m]

插入排序

插入排序的基本操作就是将一个数据插入已经排序的序列中，从而得到一个新的序列。

时间复杂度：O(n^2)

稳定性：稳定

代码实现：

默认升序

def insertSort(lst):
    #从第二个位置，即下标为1的元素开始向前插入排序。
    for i in range(1,len(lst)):
        #从第i个元素开始向前比较，如果小于前一个元素，交换位置。
        for j in range(i,0,-1):
            if lst[j]<lst[j-1]:
                lst[j],lst[j-1]=lst[j-1],lst[j]

自定义排序方式参考冒泡排序，根据参数设置排序表达式。

快速排序

快速排序又称划分交换排序，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据逗比另一部分的所有数据都要小，然后再对这两部分分别进行快速排序，以此类推。

步骤：

1. 从数列中挑出一个元素，称为基准
2. 进行排序，首先将序列分成两个分区，将比基准大的数都放在右边，小于或等于都放在左边。
3. 再对这两部分分别重新选择新的基准进行排序，直到各个分区只有一个数为止。

时间复杂度：O(n^2)

稳定性：不稳定

代码实现：

def quickSort(lst,start,end):
    #设置递归的退出条件
    if start>=end:
        return
    #设置起始元素为基准元素
    mid=lst[start]
    #low为序列左边的由左向右移动的游标
    low=start
    #high为序列右边的由右向左移动的游标
    high=end

    while low<high:
        #如果low与high未重合，high指向的元素大于等于基准元素，则high向左移动
        while low<high and lst[high]>=mid:
            high-=1
        #该循环结束时，将high指向的元素放在low的位置上
        lst[low]=lst[high]

        #开始从左向右遍历。如果，low与high未重合，且lst[low]<mid，则low向右移动
        while low <high and lst[low]<mid:
            low+=1
        #该循环结束时，将low指向的元素赋值给high
        lst[high]=lst[low]

    #当该层循环结束时，low与high重合，将mid放到该位置。
    lst[low]=mid

    #对基准左边的序列元素进行快速排序。
    quickSort(lst,start,low-1)
    #对基准右边的序列元素进行快速排序。
    quickSort(lst,low+1,end)

希尔排序

希尔排序（shell sort）是插入排序的一种。设定序列有N个元素，首先取一个整数m（小于N）作为间隔将全部元素分为m个子序列，所有距离为m的元素放在同一个子序列中，在每一个子序列中进行直接插入排序。然后再缩小m间隔，重复上述的操作，直到最后取m=1为止。

时间复杂度：O(nlogn)

稳定性：不稳定

代码实现

def shellSort(lst):
    #设置步长
    step=len(lst)/2
    while step>0:
        for i in range(step,len(lst)):
            #已步长step进行插入排序
            while i>=step and lst[i]<lst[i-step]:
                lst[i],lst[i-step]=lst[i-step],lst[i]
                i-=step
        step=step/2
    return lst

归并排序

归并排序是采用分治法的一个典型的应用。假设初始序列有n个元素，首先把每一个元素都分成一个子序列，然后两两合并，得到n/2个长度为2的有序子序列，然后在 两两合并，最终得到一个长度为n的有序序列。

时间复杂度：O(nlogn)

稳定性：稳定

代码实现

def mergeSort(lst):
    if len(lst)<=1:
        return lst
    #二分分解
    num=len(lst)/2
    left=mergeSort(lst[:num])
    right=mergeSort(lst[num:])
    #合并
    return merge(left,right)

def merge(left,right):
    '''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
    l,r=0,0
    result=[]
    while l<len(left) and r<len(right):
        if left[l]<=right[r]:
            result.append(left[l])
            l+=1
        else:
            result.append(right[r])
            r+=1
    result+=left[l:]
    result+=right[r:]
    return result