经典算法：排序算法整理

• 经典算法：排序算法整理
  • 1. 排序算法梳理
  • 2. 具体排序算法考察
    • 1. 选择排序
    • 2. 冒泡排序
    • 3. 快速排序
    • 4. 堆排序
    • 5. 归并排序
  • 3. 总结
  • 4. 参考链接

1. 排序算法梳理

前两天做每日一题遇到了一道排序题，想想自从用了python之后貌似就几乎再没有自己实现过排序算法了。

所以，这里，我们就简单整理一下一些常用的排序算法，具体包括：

1. 选择排序
2. 冒泡排序
3. 快速排序
4. 堆排序
5. 归并排序

2. 具体排序算法考察

1. 选择排序

排序算法大约是排序算法中最简单的一种实现了，其核心思想就是每次找到最小的元素拍到队伍的最前方，直至所有的元素全部排序完成。

给出python代码实现如下：

def select_sort(nums):
    n = len(nums)
    for i in range(n-1):
        idx = i
        for j in range(i+1, n):
            if nums[j] < nums[idx]:
                idx = j
        nums[i], nums[idx] = nums[idx], nums[i]
    return

显而易见的，选择排序的时间复杂度为$O(N^2)$。

2. 冒泡排序

冒泡排序也是最常使用的排序算法之一，其核心思路顾名思义，就是在每一次遍历中，将大的元素往后移动，从而实现最终的排序。

给出python代码实现如下：

def bubble_sort(nums):
    n = len(nums)
    for i in range(n-1):
        cnt = 0
        for j in range(i, n-1):
            if nums[j] > nums[j+1]:
                nums[j+1], nums[j] = nums[j], nums[j+1]
                cnt += 1
        if cnt == 0:
            break
    return nums

可以看到：

• 整体而言，冒泡排序的时间复杂度也是$O(N^2)$，但是，不同于选择排序，由于冒泡排序一直在对元素进行移动，因此有一定的概率会在中途就达到顺序的情况，从而跳出循环，因此，冒泡排序的效率上会略高于选择排序，但是不会是什么太大的提升就是了。

3. 快速排序

快速排序较之上述的选择排序还有冒泡排序在时间复杂度上有了明显的提升，通常情况下可以达到$O(NlogN)$的时间复杂度量级，不过并不总是能够做到，最差的情况下时间复杂度会退化到$O(N^2)$量级。

快速排序的核心思路是每次取一个元素作为锚点，将所有比它小的元素放置到他的前方，所有比它大的放置到它的后方，然后对前方和后方的元素重复操作进行排序。

给出python代码实现样例如下：

def quick_sort(nums):
    if len(nums) == 0:
        return []
    i, j = 0, len(nums)
    flag = nums[0]
    while i < j:
        while i < j and nums[j] >= flag:
            j -= 1
        if i < j:
            nums[i] = nums[j]
            i += 1
        while i < j and nums[i] <= flag:
            i += 1
        if i < j:
            nums[j] = nums[i]
            j -= 1
    nums[i] = flag
    return quick_sort(nums[:i]) + [flag] + quick_sort(nums[i+1:])

4. 堆排序

堆排序的核心是采用堆结构，有关python中堆结构的使用可以参看之前我之前写的一篇博客Python笔记：heapq库简介，里面有介绍python中堆结构的实现，我自己也在里面实现了一遍，因此这里就不再赘述这部分内容了。

我们直接使用heapq库来给出堆排序的实现代码如下：

import heapq

def heap_sort(nums):
    nums = heapq.heapify(nums)
    ans = []
    while nums:
        ans.append(heapq.heappop(nums))
    return ans

堆排序的时间复杂度同样是$O(NlogN)$，且不同于快速排序，堆排序的时间复杂度几乎没有抖动，在最好与最差的条件下都是$O(NlogN)$。

5. 归并排序

归并排序的核心思路有点类似平衡和二叉树。

首先，将数组拆分为等长的两个子串，而后对两个子串递归地调用归并排序，得到两个有序的子串，然后将这两个子串重新合并为一个有序的数组。

给出python代码实现如下：

def merge_sort(nums):
    if len(nums) <= 1:
        return nums
    mid = len(nums) // 2 + 1
    left = merge_sort(nums[:mid])
    right = merge_sort(nums[mid:])
    res = []
    while left and right:
        if left[0] <= right[0]:
            res.append(left.pop(0))
        else:
            res.append(right.pop(0))
    if left:
        res += left
    else:
        res += right
    return res

同样，归并排序的时间复杂度也同样是$O(NlogN)$，且和堆排序一样，不会有太大的抖动，在最好和最坏的情况下均为$O(NlogN)$。

3. 总结

我们整理上述提到的一些常用的排序算的时间复杂度如下表所示：

排序算法	最优时间复杂度	最坏时间复杂度	平均时间复杂度
选择排序	$O(N^2)$	$O(N^2)$	$O(N^2)$
冒泡排序	$O(N)$	$O(N^2)$	$O(N^2)$
快速排序	$O(NlogN)$	$O(N^2)$	$O(NlogN)$
堆排序	$O(NlogN)$	$O(NlogN)$	$O(NlogN)$
归并排序	$O(NlogN)$	$O(NlogN)$	$O(NlogN)$

除了上述一些算法之外，常见的排序算法还有希尔排序，桶排序等等，不过我并不怎么熟悉，因此这里就不再过多展开了，平时也不怎么用得到，如果读者有兴趣的话可以看一下下述参考链接中的内容，个人觉得他讲的还是蛮好的。

4. 参考链接

1. https://www.cnblogs.com/onepixel/articles/7674659.html