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:            returnif __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:                breakif __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 //= 2if __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 resultif __name__ == '__main__':    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]    print(li)    sort_li = merge_sort(li)    print(sort_li)