【Python】排序问题小结

1、排序算法性能总结

排序方法	平均时间复杂度	最差时间复杂度	最好时间复杂度	空间复杂度	稳定性
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
双向冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
希尔排序	O(n^1.3)	O(n^2)	O(n)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快排	O(nlogn)	O(n^2)	O(nlogn)	O(logn)	不稳定

2、几点疑问，以及我个人觉得比较好的解答：

• 到达nlogn级别的排序算法，一共有三种，分别是堆排序，归并排序以及快速排序，其中只有归并排序最稳定。那么，为什么要说快速排序的平均情况是最快的呢？https://blog.csdn.net/qq_39521554/article/details/79364718
• 冒泡排序和双向冒泡排序对比：https://blog.csdn.net/lemon_tree12138/article/details/50591859

3、Po代码：

#1、选择排序
def selection_sort(list_x):
    for i in range(0, len(list_x)):
        min_index = i
        for j in range(i+1, len(list_x)):
            if list_x[j] < list_x[min_index]:
                min_index = j
            if i != min_index:
                list_x[i], list_x[min_index] = list_x[min_index], list_x[i]
    return list_x

#2、冒泡排序
def bubble_sort(list_x):

    n = len(list_x)

    for i in range(n-1):

        count = 0
        
        for j in range(n-1-i):

            if list_x[j] > list_x[j+1]:
                list_x[j], list_x[j+1] = list_x[j+1], list_x[j]
                count += 1
        if count == 0:
            break
    return list_x

#3、双向冒泡排序（鸡尾酒排序）
def bidirectionalbubble_sort(x):
    j = 0
    while j <= len(x)//2:
       flag = False
       for i in range(j ,len(x) - j -1):
           if x[i]>x[i+1]:
               x[i], x[i+1] = x[i+1], x[i]
               flag=True
       for i in range(len(x)- 1 - j,j,-1):
           if x[i]<x[i-1]:
               x[i], x[i-1] = x[i-1], x[i]
               flag=True    
       if not flag:  
           return x
       j += 1
    return x

#4. 插入排序算法
def insert_sort(x):
    for i in range(1,len(x)):
        j = i-1
        item = x[i]
        while item < x[j] and j>=0:
            x[j], x[j+1] = x[j+1], x[j]
            j -= 1
        x[j+1] = item
    return x

#5. 希尔排序
##  与插入排序的不同之处在于，它会优先比较距离较远的元素
##  排序的本质是消除逆序对，优先比较距离较远的元素，使得一次交换能够消除一个以上的逆序对
def shell_sort(alist):
    n = len(alist)
    gap = n // 2
    while gap >= 1:
        for j in range(gap, n):
            i = j
            while (i - gap) >= 0:
                if alist[i] < alist[i - gap]:
                    alist[i], alist[i - gap] = alist[i - gap], alist[i]
                    i -= gap
                else:
                    break
        gap //= 2


#6. 归并排序
def merge (a, b):
    help = []
    i = j = 0
    while i < len(a) and j < len(b):
        if a[i] < b[j]:
            help.append(a[i])
            i += 1
        else:
            help.append(b[j])
            j += 1
    if i == len(a):
        for num in b[j:]:
            help.append(num)
    else:
        for num in a[i:]:
            help.append(num)
    return help

def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    mid_index = len(alist) // 2
    left = merge_sort(alist[: mid_index])
    right = merge_sort(alist[mid_index :])
    return(merge(left, right))


#7. 快排
def quick_sort(alist):
    mid_index = len(alist) // 2
    if mid_index == 0:
        return alist
    mid = []
    left = []
    right = []
    for i in range(len(alist)):
        if alist[i] < alist[mid_index]:
            left.append(alist[i])
        elif alist[i] == alist[mid_index]:
            mid.append(alist[i])
        else:
            right.append(alist[i])
    return quick_sort(left)+mid+quick_sort(right)


if __name__ == '__main__':
    list_a = [1, 5, 6, 2, 1, 9, 3, 8, 9, 12]
    print(bubble_sort(list_a))
    print(selection_sort(list_a))
    print(bidirectionalbubble_sort(list_a))
    print(insert_sort(list_a))
    print(merge_sort(list_a))
    print(quick_sort(list_a))