Python中六大排序算法与代码实现

排序
排序算法是一种能将一串数据按照特定顺序进行排序的一种算法


排序算法的稳定性
稳定排序算法就让原本有相等键值的记录维持相对次序。
就是在第一排序之后，次序与原来顺序保持一致的就是稳定的。

冒泡排序
最优时间复杂度：O(n)表示遍历一次没有发现任何可以交换的元素，排序结束
最坏时间复杂度：O(n^2)
稳定性：稳定

def bubble_sort(alist):
    n = len(alist)
    for j in range(n - 1):
        count = 0
        for i in range(0, n - j - 1):
            if alist[i] > alist[i + 1]:
                alist[i], alist[i + 1] = alist[i + 1], alist[i]
                count += 1
        # 这个列表如果你一步都没有移动，肯定是排好序的
        # 此处优化能将算法最优复杂度降到O(n)，但是最坏复杂度还是O(n^2)
        if 0 == count:
            return

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    bubble_sort(li)
    print(li)

选择排序
从无序中找到最小的依次排序
选择排序是一种简单直观的排序算法。他的工作原理如下，首先在排序序列中找到最小的元素，存放到排序序列的起始位置，然后，再从剩余未排到元素中继续寻找最小元素，然后放到已排序序列的末尾。以此类推。。。
选择排序的主要优点与数据移动有关
最优时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
稳定性：不确定(考虑升序每次选择最大的情况)

# 选择排序
def select_sort(alist):
    n = len(alist)
    for j in range(0, n - 1):
        index_min = j
        for i in range(j + 1, n):
            if alist[i] < alist[index_min]:
                index_min = i
        # 上面只换了下标，下面这行代码换了下标所指的值
        alist[index_min], alist[j] = alist[j], alist[index_min]

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    select_sort(li)
    print(li)

插入排序
从后面选中一个，在前面进行排序，和选择是相反的，选择排序是选大小再排序，而插入排序是先选数，再排大小
最优时间复杂度：O(n) (升序排列，序列已经处于升序状态)
最坏时间复杂度：O(n^2)
稳定性：稳定

# 插入排序
# 第一个循环，是外部选择排序数的循环，第二个循环是内部进行排序的循环，这个过程和选择排序刚好相反
def insert_sort(alist):
    n = len(alist)
    for j in range(1, n - 1):
        i = j
        # 优化算法，此时如果输入有效数列，则内部排序循环只执行一次，就break了，降低了时间复杂度
        while i > 0:
            if alist[i] < alist[i - 1]:
                alist[i], alist[i - 1] = alist[i - 1], alist[i]
                i -= 1
            else:
                break

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    insert_sort(li)
    print(li)

希尔排序
希尔排序是插入排序的一种，也成缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减少至1时，整个文件掐被分成一组，算法被终止。
把原来一组分成多组，对每组使用插入排序，再合并，然后减少间隔数，在分组，在排序，再合并，以此类推，取好间隔的话，确实可以有效的降低时间复杂度
最有时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O(n^2)
稳定性：不稳定

# 希尔排序
def shell_sort(alist):
    n = len(alist)
    gap = n // 2

    while gap > 0:
        # 插入算法，与普通的插入算法的区别就是gap步长
        for j in range(gap, n):
            i = j
            while i > 0:
                if alist[i] < alist[i - gap]:
                    alist[i - gap], alist[i] = alist[i], alist[i - gap]
                    i -= gap
                else:
                    break

        # 缩短gap步长
        gap //= 2

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    shell_sort(li)
    print(li)

快速排序
将第一个数存储起来，左右各一个指针，右边指针向左移动，由于第一个数被取出，首先移动右边指针，当数大于第一个数时，则向左移动，比第一个小的时候就停下来，将这个数放到第一位，此时左边指针向右移动，遇到比第一个数小的数就持续向右移动，遇到比第一个数大的数就停下来，把这个数放到右边，开始右边指针移动，以此类推，当两个指针重合时，此时就找到第一个数的位置了，此数两边，再各成一个子列进行上述操作。
最优时间复杂度：O(nlogn) 在竖向上，是2^x = n,解出来x=logn，因为每次都会产生一倍，第一次产生了两个子列，逐渐对半，最后到每个元素只剩自身一个的时候终止，
但是总和依然是n，所以是logn，横向上一共是n，所以总和是n*logn
最坏时间复杂：竖向上每次都是第一个，那么有n个，横向上还是n，则是n*n
稳定性：不稳定，因为有跳跃取值，不像冒泡，冒泡之所以稳定，不存在跳跃取值。

# 快速排序
# 有自身递归
def quick_sort(alist, first, last):
    middle_value = alist[first]
    low = first
    high = last

    if first >= last:
        return
    while low < high:
        # low 右移
        while low < high and alist[low] < middle_value:
            low += 1
        alist[high] = alist[low]

        #  high 左移
        # = 是为了处理相同字母的情况，放在上面不行，只能放在这里
        while low < high and alist[high] >= middle_value:
            high -= 1
        alist[low] = alist[high]

    # 从循环退出时，low == high
    alist[low] = middle_value

    # 这个地方为什么这么写而不用切片？
    # 你要注意此时传进来的值依然是一个完整的列表，所以要有起始和终止值，但仍然归于alist，你用切片意味着传进来一个新的列表，这就无法和上述的
    # 快排统一起来
    # 对low左边的列表执行快速排序
    quick_sort(alist, first, low - 1)
    # 对low右边的列表排序
    quick_sort(alist, low + 1, last)

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    quick_sort(li, 0, len(li) - 1)
    print(li)

归并排序
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组

将数据分解到最小之后，然后合并两个有序数组，基本思想是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分赋值过来即可

最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
稳定性：稳定
归并算法是涉及到额外的开销，这是和其他几种排序算法所不同的，但是归并算法确实可以有效的减少最坏时间复杂

# 归并排序
def merge_sort(alist):
    n = len(alist)
    if n <= 1:
        # 这个地方一定要有返回值，因为alist是被分解成的单一的元素
        return alist
    mid = n // 2

    # left 采用递归排序后形成的新序列
    left_li = merge_sort(alist[:mid])

    # right 采用递归排序后形成的新序列
    right_li = merge_sort(alist[mid:])

    # print(left_li,right_li)

    # 将两个子序列合并成一个序列
    # 左右指针
    left_pointer, right_pointer = 0, 0
    result = []

    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] <= right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1

    # 此时还有最后一个元素没有加入到列表中，切片是没有越界的，它返回一个空列表
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    sort_li = merge_sort(li)
    print(sort_li)