常用排序算法总结（Python实现）（待补充）

排序算法 平均时间复杂度

冒泡排序 O(n2)
选择排序 O(n2)
插入排序 O(n2)
希尔排序 O(n1.5)
快速排序 O(NlogN)
归并排序 O(NlogN)
堆排序 O(N*logN)
基数排序 O(d(n+r))

一. 冒泡排序(BubbleSort)

基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。

python代码实现：

# @Time: 2020/4/16 10:08
# @Auther: zhangzheng
# @E-mail: [email protected]

# 冒泡排序  平均时间复杂度：O(n2)

# def bubble_sort(alist):
#     for i in range(0, len(alist)-1):
#         for j in range(0, len(alist)-1-i):
#             if alist[j] > alist[j+1]:
#                 alist[j],alist[j+1]= alist[j+1], alist[j]
#
#     return alist
# sorted_list = bubble_sort([1,3,5,2,4])
# print(sorted_list)

# 优化代码
def bubble_sort(alist):
    for i in range(0, len(alist)-1):
        flag = 0
        for j in range(0, len(alist)-1-i):
            if alist[j] > alist[j+1]:
                alist[j], alist[j+1] = alist[j+1], alist[j]
                flag += 1
        if flag == 1:
            return alist

    return alist
sorted_list = bubble_sort([1,3,5,2,4])
print(sorted_list)

二. 选择排序(SelctionSort)

基本思想：
在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换；
第二次遍历n-2个数，找到最小的数值与第二个元素交换；
。。。
第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成。

python代码实现：

# @Time: 2020/4/16 10:09
# @Auther: zhangzheng
# @E-mail: [email protected]

# 选择排序 平均时间复杂度：O(n2)

def selected_sort(alist):
    min_index = 0
    for i in range(0, len(alist)-1):
        for j in range(i, len(alist)):
            if alist[j] < alist[min_index]:
                min_index = j
        alist[i], alist[min_index] = alist[min_index], alist[i]
        min_index = i + 1
    return alist

sorted_list = selected_sort([2,5,1,3,4])
print(sorted_list)

三. 插入排序(Insertion Sort)

基本思想：
在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

python代码实现：

# @Time: 2020/4/16 13:31
# @Auther: zhangzheng
# @E-mail: [email protected]

# 插入排序

def inserted_sort(original_list):
    for i in range(1, len(original_list)):
        while i >0:
            if original_list[i] < original_list[i-1]:
                original_list[i], original_list[i-1] = original_list[i-1], original_list[i]
                i -= 1
            else:
                break
    return original_list

sorted_list = inserted_sort([1,3,5,2,4])
print(sorted_list)

四、希尔排序(Shell Sort)

前言：
数据序列1： 13-17-20-42-28 利用插入排序，13-17-20-28-42. Number of swap:1;
数据序列2： 13-17-20-42-14 利用插入排序，13-14-17-20-42. Number of swap:3;
如果数据序列基本有序，使用插入排序会更加高效。

基本思想：
在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。

python代码实现：

# @Time: 2020/4/17 9:18
# @Auther: zhangzheng
# @E-mail: [email protected]

# 希尔排序

def shell_sort(ori_list):
    gap = len(ori_list)  // 2
    while gap >= 1:
        for i in range(gap, len(ori_list)):
            while i > 0:
                if ori_list[i] < ori_list[i - gap]:
                    ori_list[i], ori_list[i - gap] = ori_list[i - gap],ori_list[i]
                    i -= gap
                else:
                    break
        gap //= 2
    return ori_list

sorted_list = shell_sort([2, 5, 3, 4, 1])
print(sorted_list)

五. 快速排序(Quicksort)

基本思想：（分治）

先从数列中取出一个数作为key值；
将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边；
对左右两个小数列重复第二步，直至各区间只有1个数。

python代码实现：

六. 归并排序(Merge Sort)

基本思想：参考
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。
首先考虑下如何将2个有序数列合并。这个非常简单，只要从比较2个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

python代码实现：