别说我不懂排序！几种常见排序算法（二）

part4：归并排序

归并排序的基本思想是分而治之（D&C）。D&C的工作原理如下：

• 找出最简单的基线条件；
• 确定如何缩小问题的规模，使其符合基线条件。

归并排序的动态图如下：

注意点：在排序过程中我们引入一个中间列表（tmpArr），用来存放合并后的列表。

代码实现

def recMergeSort(arr,first,last,tmpArr):
    if first ==last:
        return arr
    else:
        mid = (first+last)//2
        recMergeSort(arr,first,mid,tmpArr)
        recMergeSort(arr,mid+1,last,tmpArr)
        mergeTwoOrderedSubArr(arr,first,mid+1,last+1,tmpArr)




def mergeTwoOrderedSubArr(arr,left,right,end,tmpArr):
    a = left
    b = right
    m =0
    # merge the two arr together until one is empty
    while a<right and b<end:
        if arr[a]<arr[b]:
            tmpArr[m]=arr[a]
            a+=1
        else:
            tmpArr[m]=arr[b]
            b+=1
        m+=1
    # If the left subArr contains more items apend them to tmpArr
    while a<right:
        tmpArr[m]=arr[a]
        a+=1
        m+=1
    # If the left subArr contains more items apend them to tmpArr
    while b<end:
        tmpArr[m] =arr[b]
        b+=1
        m+=1
    #copy the sorted subseq back into the original arr
    for i in range(end-left):
        arr[i+left]=tmpArr[i]

def mergeSort(arr):
    n =len(arr)
    tmpArr = arr.copy()
    recMergeSort(arr,0,n-1,tmpArr)
    return arr

part5：快速排序

快速排序的基本思想也是分而治之（D&C）。

一般步骤

• 从列表中选择一个数字作为基准数，也可以叫它分界点。
• 将列表按照分界点划分成为两部分，分界点左侧的数比分界点小（大），分界点右侧的数比分界点大（小）。
• 对分界点左侧和右侧的子列表进行同样的操作，直到排序成功。

代码实现

方案一：

def quick_sort(arr):
    if len(arr)<2:
        return arr
    else:
        pivot =arr[0]
        less = [i for i in arr[1:] if i<pivot]
        greater =[i for i in arr[1:] if i> pivot]
        return quockSort(less)+[pivot]+quockSort(greater)

方案二：

def quick_sort(arr,first,last):
    if first <last:
        pos =partition1(arr,first,last)
        # pos =partition2(arr,first,last)
        quick_sort(arr,first,pos-1)
        quick_sort(arr,pos+1,last)

首元素设置为基准数

def partition2(arr,first,last):
    # 设置基准数所在的位置
    pivot =first 
    #设置两个游标，一头一尾
    i,j =first,last
    while i !=j:
        # 每次循环时候都是从j游标开始移动
        while arr[j]>=arr[pivot] and i<j:
            # pass
            j -=1
        # 当j游标停止时，开始移动i游标
        while arr[i]<=arr[pivot] and i<j:
            # pass
            i +=1
        # 当i游标停止时，将i,j 内容交换
        if i<j:
            arr[i],arr[j] =arr[j],arr[i]
    arr[pivot],arr[i]=arr[i],arr[pivot]
    return i

尾元素设置为基准数

def partition1(arr,first,last):
    wall =first
    for i in range(first,last):
        if arr[i]<arr[last]:
            arr[i],arr[wall] =arr[wall],arr[i]
            wall +=1
    arr[wall],arr[last] =arr[last],arr[wall]

    return wall

part6：梳排序

探索发现

这次我们要讨论的是梳排序（Comb Sort）。先看一张动态图。

• 一个显著的特征：两条红杠之间的距离在缩小。

还记得冒泡排序吗？比较的是相邻两个元素。相邻的位置我们认为步长为1。梳排序每一趟的步长大小是动态改变的。你只需要定义一种步长改变的规则，然后开始排序，就这么简单。

代码示例

def comb_sort(arr):
    def swap(i,j):
        arr[i],arr[j] =arr[j],arr[i]

    n =len(arr)
    sorted =False
    shink =1.3
    step =n
    while not sorted:
        # 定义步长改变的规则
        step =int(floor(step/shink))
        if  step>1:
            sorted =False
        else:
            step=1
            sorted =True

        i=0
        # for i in range(n):
        while i+step <n:
            # pass
            # if i+step<n:
            #交换的条件
            if arr[i]>arr[i+step]:
                swap(i,i+step)
                sorted =False
            i =i+1