冒泡排序
-
時間複雜度:
最優時間複雜度:O(n)(表示遍歷一次沒有發現任何可以交換的元素,排序結束)
最壞時間複雜度:O(n**2) -
穩定性:穩定
def bubble_sort(alist):
n = len(alist)
for j in range(n-1):
# print('')
count = 0
for i in range(n-1-j):
if alist[i] > alist[i+1]:
alist[i],alist[i+1] = alist[i+1],alist[i]
count += 1
if count == 0:
break
對一萬個數據進行排序時間:
排序三次,平均時間爲11.82
選擇排序
-
時間複雜度
最優時間複雜度:O(n2)
最壞時間複雜度:O(n2) -
穩定性:
不穩定(考慮升序每次選擇最大的情況)
def selection_sort(alist):
n = len(alist)
for j in range(0,n-1):
for i in range(j+1,n):
if alist[j] > alist[i]:
alist[i], alist[j] = alist[j], alist[i]
對一萬個數據進行排序時間:
排序三次,平均時間爲5.2
冒泡排序和選擇排序相比,冒泡排序是相鄰兩個元素比較,符合要求交換一次;選擇排序是一個元素與後邊元素比較,符合要求交換一次。所以對於同一組數據來說,選擇排序交換次數要少於冒泡排序的,所以效率高
插入排序
-
時間複雜度
最優時間複雜度:O(n)(升序排列,序列已經處於升序狀態)
最壞時間複雜度:O(n**2) -
穩定性:穩定
def insert_sort(alist):
n = len(alist)
for i in range(n):
for j in range(i):
if alist[i] < alist[j]:
alist[i], alist[j] = alist[j], alist[i]
對一萬個數據進行排序時間:
排序三次,平均時間爲5.1,比選擇排序稍微快一點點
有一位博主的寫法利用了Python列表的方法,更快:
def insert_sort(ilist):
for i in range(len(ilist)):
for j in range(i):
if ilist[i] < ilist[j]:
ilist.insert(j, ilist.pop(i))
break
只用了1.7秒左右
這種方式不用交換,只需要遍歷列表找到指定的位置即可
希爾排序
-
時間複雜度:
最優時間複雜度:根據步長序列的不同而不同
最壞時間複雜度:O(n**2) -
穩定性:不穩定
def shell_sort(alist):
n = len(alist)
gap = n // 2
while gap > 0:
for j in range(gap, n):
i = j
while i > 0:
if alist[i] < alist[i-gap]:
alist[i], alist[i-gap] = alist[i-gap], alist[i]
i -= gap
else:
break
gap //= 2
對一萬個數據進行排序時間:
歸併排序
-
時間複雜度:
最壞時間複雜度:O(nlogn)
最優時間複雜度:O(nlogn) -
穩定性:穩定
def merge_sort(alist):
n = len(alist)
# print(alist)
if n <= 1:
return alist
mid = n//2
#left_li 採用歸併排序後形成的有序的新的列表
left_li = merge_sort(alist[:mid])
#right_li 採用歸併排序後形成的有序的新的列表
right_li = merge_sort(alist[mid:])
#將兩個有序的子序列合成一個新的整體
left_pointer,right_pointer = 0,0
print(left_li)
print(right_li)
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
對一萬個數據進行排序時間:
快速排序
-
時間複雜度:
最優時間複雜度:O(nlogn)
最壞時間複雜度:O(n**2) -
穩定性:不穩定
def quick_sort(alist, first, last):
if first >= last:
return
mid_value = alist[first]
low = first
high = last
while low < high:
#high左移
#當low和high的值等於,把相同的值放在分界線一邊
while low < high and alist[high] >= mid_value:
high -= 1
alist[low] = alist[high]
#low右移
while low < high and alist[low] < mid_value:
low += 1
alist[high] = alist[low]
#從循環退出時,low==high
alist[low] = mid_value
# print(alist)
#對low左邊的列表執行快速排序
quick_sort(alist, first, low-1)
#對low右邊的列表執行快速排序
quick_sort(alist, low+1, last)
這種方法不好理解
百度百科的方法簡單易懂:
def quick_sort(data):
"""快速排序"""
if len(data) >= 2: # 遞歸入口及出口
mid = data[len(data)//2] # 選取基準值,也可以選取第一個或最後一個元素
left, right = [], [] # 定義基準值左右兩側的列表
data.remove(mid) # 從原始數組中移除基準值
for num in data:
if num >= mid:
right.append(num)
else:
left.append(num)
return quick_sort(left) + [mid] + quick_sort(right)
else:
return data
對一萬個數據進行排序時間:
本文所用的數據是隨機生成的一萬個整數,幾種排序用的是一樣的數據。
幾種排序是從b站上學習的:https://www.bilibili.com/video/BV1p441167Wc/?spm_id_from=333.788.videocard.3
排序具體代碼實現有多種寫法,如果有錯誤請大家指出。