算法入门——分而治之思想之快速排序与归并排序

最新推荐文章于 2023-01-16 13:35:27 发布

中意灬

最新推荐文章于 2023-01-16 13:35:27 发布

阅读量1.3k

点赞数 1

分类专栏：数据结构与算法文章标签：算法排序算法 python

本文链接：https://blog.csdn.net/qq_55977554/article/details/122810814

版权

数据结构与算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

分而治之

分而治之（divide and conquer，D&C）——一种著名的递归式问题解决方法。

所谓“分而治之” 就是把一个复杂的算法问题按一定的“分解”方法分为等价的规模较小的若干部分，然后逐个解决，分别找出各部分的解，把各部分的解组成整个问题的解，这种朴素的思想来源于人们生活与工作的经验，也完全适合于技术领域。诸如软件的体系结构设计、模块化设计都是分而治之的具体表现。

使用D&C解决问题的过程包括两个步骤：

（1）找出基线条件（终止递归的条件），这种条件尽可能简单。

（2）不断将问题分解（或者说缩小规模），直到符合基线条件

（3）将拆分的子问题的解逐层返回合并成原问题的解

我们以一个例子来说明，我们给定一个数组[1,2,3,4,5,6]，我们需要将这些数字相加，并返回他们的和。首先，这个问题可以使用一个for循环就能解决，但是如何用递归函数来完成这个任务呢？

第一步：找出基线条件，就是该何时停止递归了，我认为数组包含一个或0个元素就该终止了

第二步：缩小问题规模，就是每次递归我们都要离基线条件越来越近。

sum([1,2,3,4,5,6])=21似乎与1+sum([2,3,4,5,6])=1+20=21等效的，但是问题的规模，似乎缩小了欸。

第三步：返回每层子问题的解合并成原问题的解。

python代码实现

def sum(arr):
    """基线条件"""
    if len(arr)<=1:
        return arr[0]
    '''递归条件'''
    return arr.pop()+sum(arr)
if __name__ == '__main__':
    arr=[1,2,3,4,5,6]
    print(sum(arr))

这只是举个例子来说明D&C这种思想，但这个求和的算法效率其实并不比循环的效率高，甚至肯会更糟。

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用D&C的一个非常典型的应用。

合并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。归并排序也称合并排序。

关于归并排序的图解，大家可以去阅读这篇文章图解排序算法(四)之归并排序 - dreamcatcher-cx - 博客园

python代码实现

"""归并"""
def Merge_sort(arr):
    if len(arr)<=1:
        return arr
    mid=len(arr)//2
    """递归划分成两个数组"""
    left=Merge_sort(arr[:mid])
    right=Merge_sort(arr[mid:])
    return Sort(left,right)

"""排序"""
def Sort(a,b):
    c=[]
    while len(a)>0 and len(b)>0:
        """如果a的第一个元素比b的第一个元素大，就将b的第一个元素弹出并添加到数组c中，
        反之就将a的第一个元素弹出并添加到c中，当a或者b中任意一个数组为空时，跳出循环"""
        if a[0]>b[0]:
            c.append(b.pop(0))
        else:
            c.append(a.pop(0))
    """如果a数组为空，就将b数组添加到c中，反之相同"""
    if len(a)==0:
        c.extend(b)
    else:
        c.extend(a)
    return c
if __name__ == '__main__':
    a=[2,6,5,20,1,4,22]
    print(Merge_sort(a))

测试结果：

[1, 2, 4, 5, 6, 20, 22]

时间复杂度

归并排序的时间复杂度为O(n*logn)，最平均情况和最糟情况均为O(n*logn),因为它的归并时间复杂度为O(logn),排序的时间复杂度为O(n),故总的时间复杂度为O(nlogn)。

快速排序

快速排序是一种常用的排序算法，比选择排序快许多，是冒泡排序算法的优化，也是D&C思想的体现。

快速排序算法通过多次比较和交换来实现排序，其排序步骤如下：

（1）选取基准值（pivot）

（2）根据基准值将数组分成两个子数组：小于基准值和大于基准值的数组

（3）对这个两个子数组重复上述操作，直至满足基准条件

我们以排序数组[2,0,5,3,1,6]为例，它的步骤如下所示

python代码实现

def Quick_sort(arr):
    """基线条件"""
    if len(arr)<1:
        return arr
    pivot=arr[0]#选取基准值
    left=Quick_sort([i for i in arr[1:] if i<pivot])#小于基准值
    right=Quick_sort([i for i in arr[1:] if i>=pivot])#大于基准值
    result=left+[pivot]+right
    return result
if __name__ == '__main__':
    a=[2,0,5,3,1,6]
    print(Quick_sort(a))

测试结果：

[0, 1, 2, 3, 5, 6]

时间复杂度

快速排序的性能依赖于你选择的基准值，平均情况（最优情况）下的时间复杂度为O(nlogn)，最糟情况下的时间复杂度为O( $n^2$ )。假如每次我们选择数组第一个元素为基准值，且要排序的数组是有序的，那么其递归次数为n，即调用栈的高度为n，栈长为O(n)，调用栈每层都涉及O(n)个元素，所以总的时间复杂度为为O( $n^2$ )；假如每次我们选择数组中间值为基准值，那么其递归次数为 $log_2{n}$ ，栈长为O( $log_2{n}$ )，调用栈每层也涉及O(n)个元素，所以总的时间复杂度为O(nlogn)。