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))