排序算法

排序算法

参考：https://www.cnblogs.com/onepixel/articles/7674659.html

什么是稳定性

有两个变量a, b 满足a = b；原本a在b的前面，排序之后，如果a仍在b的前面，这个算法稳定，如果a排序后出现在了b的后面，就是不稳定。

冒泡排序

时间复杂度：$O(n^2)$， 时间复杂度：$O(1)$，稳定性：稳定

思路

假设数组中每个数字都是该元素对应的质量，那么每次把质量较大的元素沉到数组的后面，那么比较轻的元素就会出现在数组前面。整个过程就像冒泡的过程。在实现的时候，外循环控制的是扫描的次数，而内循环要实现两两交换，一个内循环下来，最大的就会被放在最后。
当然也有相应的优化方法，比如用一个标记去记录当下是否进行交换，如果内循环结束后没有修改这个标记，就说明数组内的元素都是有序的，外循环也可以随即停止。

代码

def maopao(nums):
    if not nums:
        return []
    for i in range(len(nums)):
        change = False
        for j in range(len(nums)-i-1):
            if nums[j] > nums[j+1]:
                nums[j+1], nums[j] = nums[j], nums[j+1]
                change = True
        if not change:
            break
    return nums

选择排序

时间复杂度：$O(n^2)$， 时间复杂度：$O(1)$，稳定性：不稳定

思路

代码

def select(nums):
    if not nums:
        return nums
    for i in range(len(nums)):
        min_num = nums[i]
        for j in range(i+1, len(nums)):
            if nums[j] < min_num:
                min_num = nums[j]
        nums[i], min_num = min_num, nums[i]
    return nums
print(select([1, 5, 3, 7, 5, 8, 9]))

插入排序

时间复杂度：$O(n^2)$， 时间复杂度：$O(1)$，稳定性：稳定

思路

插入排排序是每次拿到新的元素就把这个新的元素和新元素前面的有序数组的元素逐个对比，找到他在前面这个有序数组中的位置，插入进去。
插入的实现，在计算机中，是把当下要比较的元素用变量记录下来，然后这个当下元素之前的有序数组中每个元素依次复制赋值给下一位。

代码

def insert(nums):
    if not nums: return nums
    for i in range(1, len(nums)):
        cur = nums[i]
        pre_index = i - 1
        while pre_index >= 0 and nums[pre_index] >= cur:
            nums[pre_index+1] = nums[pre_index]
            pre_index -= 1
        nums[pre_index+1] = cur
    return nums
    
def insert_version2(nums):
    if not nums: return nums
    for i in range(1, len(nums)):
        cur = nums[i]
        for k in range(i-1, -2, -1):
            if k < 0 or nums[k] <= cur:
                nums[k+1] = cur
                break
            else:
                nums[k+1] = nums[k]
    return nums

希尔排序

时间复杂度：$O(n^{1.3})$， 时间复杂度：$O(1)$，稳定性：不稳定

思路

希尔排序，也叫缩小增量排序，被视为插入排序的一种优化排序方式。和插入排序的对比，不同之处在于，希尔排序每次不是一步一步的向前遍历，而是以一个gap的大小进行跳跃遍历。这个gap的大小会逐渐缩小。一般的初次取序列的一半为gap增量，以后每次减半，直到增量为1。希尔排序没有快速排序算法快 O(n(logn))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。

代码

def shell_sort(nums):
    if not nums:
        return nums
    
    gap = len(nums) // 2
    while gap:
        for i in range(gap, len(nums)):
            cur = nums[i]
            for k in range(i - gap, -gap-1, -gap):
                if k < 0 or nums[k] <= cur:
                    nums[k+gap] = cur
                    break
                else:
                    nums[k+gap] = nums[k]
        gap //= 2
    return nums

归并排序

时间复杂度：$O(nlogn)$， 时间复杂度：$O(n)$，稳定性：稳定

思路

一种分治的思想，先分再融合。把数组不断的从中间分开，然后

代码

快速排序

思路

代码

堆排序

思路

代码