本文對十大排序演算法進行總結和歸納，以及使用裝飾器計算程式執行消耗時間，便於在後續使用中查閱和使用
十大金典排序
def
cocktaisort
(list2):
left = 0
right = len(list2) - 1
while left < right:
for i in range(left, right, 1):
if(list2[i] > list2[i + 1]):
temp1 = list2[i+1]
list2[i+1] = list2[i]
#交換python可以直接使用：list2[i],list2[i+1] = list2[i+1], list2[i]
list2[i] = temp1
right -= 1
for i in range(right,left,-1):
if(list2[i] < list2[i - 1]):
temp1 = list2[i]
list2[i] = list2[i -1]
list2[i - 1] = temp1
left+=1
return list2
順序比較 兩兩比較，依次後移 效能較低
def
sort
(list1):
num = len(list1)
if num == 0:
return list1
for i in range(0,num,1):
iswap = false
for j in range(0,num - 1 - i,1):
if list1[j + 1] < list1[j]:
temp = list1[j + 1]
list1[j + 1] = list1[j]
list1[j] = temp
iswap = true
if (not iswap):
break
return list1
def
sort_bubble
(list1):
for i in range(len(list1)):
j = 0
while j < (len(list1) - 1 - i):
if list1[j] > list1[j + 1]:
temp = list1[j]
list1[j] = list1[j+1]
list1[j+1] = temp
j += 1
return list1
def
simpesort
(list1):
num = len(list1)
if num == 0:
return list1
for i in range(0,num):
min = i #最小值下標
for j in range(i,num): #i開始後推
if list1[j] < list1[min]: # 最小值與該值比較，符合則交換下標
min = j
temp = list1[min] #下標對應值交換
list1[min] = list1[i]
list1[i] = temp
return list1
取出i + 1的元素 與前面排好序的元素從後向前比較，小於等於則將i+1元素插入到該位置（有一定序的時候效率最高）
def
insert_sort
(list1):
length = len(list1)
if len(list1) == 0:
return list1
for i in range(1,length,1):
temp = list1[i]
preindex = i - 1
while preindex >= 0
and temp < list1[preindex]:
list1[preindex + 1] = list1[preindex]
preindex -= 1
list1[preindex + 1] = temp
return list1
排好序的為乙個陣列，未排好序的為另乙個
def binaryinsertsort(list1):
iflen(list1) == 0:
return list1
for i in range(1,len(list1)):
left = 0
right = i - 1 #有序邊界
temp = list1[i]
while
left
<= right:
mid = left + (right - left) // 2
if list1[mid] > temp:
right = mid - 1
else:
left = mid + 1
forj in range(i - 1,left,-1):
list1[j+1] = list1[j]
list1[left] = temp
return list1
空間換時間，多了乙個tmp列表占用記憶體，但時間減少為n*logn
def
merge_sort(list1):
iflen(list1) < 2:
return
list1
else:
#遞迴函式分解列表
mid = len(list1) // 2
list1_left = merge_sort(list1[:mid])
list1_right = merge_sort(list1[mid:])
tmp = list()
#tmp 為新列表 存放排好序的元素
i = 0
j = 0
k = 0
while
i < len(list1_left) or j < len(list1_right):
#迴圈條件
ifi < len(list1_left) and j < len(list1_right):
#兩個有序列表相比較，開始為乙個元素，直接累積為兩個有序列表
iflist1_left[i] < list1_right[j]:
#判斷兩個列表中元素的大小，小的放入tmp列表
i+=1
else:
j+= 1
elif
i >= len(list1_left):
#分別判斷是否超出左右列表最大下標，則只需要把左右列表合併到tmp裡 反之一樣
j+= 1
else:
i+= 1
return
tmp
def
random_sort
(sort_name):
import random
list1 = list()
for i in range(10):
print("使用%s排序結是%s"%(sort_name.__name__,sort_name(list1)))
list2 = [cocktaisort,sort,sort_bubble,simpesort,binaryinsertsort,merge_sort]
for xx in list2:
random_sort(xx)
def
dec(fun):
#裝飾器：計算執行時間
defres
(*args,**kwarges):
print('--------%s 演算法-------------' % (fun.__name__))
start = time.perf_counter()
a = fun(*args,**kwarges)
print('消耗的時間為 %s' %(time.perf_counter() - start))
print('******************')
return a
return res
在需要計算時間的函式前加上 @dec 即可（詳見test19.py）
十大排序演算法
1.非線性時間類排序 時間複雜度未突破 0 nlog 2n 不穩定的四個排序演算法 選擇排序 0 n2 希爾排序 0 n1.3 希爾排序實現python 快速排序 0 n log2 n 0 nlog 2n 0 nlog 2 n 快速排序實現c python 堆排序 0 n log2 n 0 nlog...
十大排序演算法
排序規則 從左至右依次增大 一 基於比較的排序演算法 插入排序 逐個遍歷未排序序列，將其在已排序序列中從右到左比較，直到遇到比自己小的數，然後將元素插入到那個數的後面，有序序列從左向右生長。選擇排序 在未排序序列中選擇最小的元素，將其插入到已排序序列的末尾，有序序列從左向右生長。氣泡排序 從左至右逐...
十大排序演算法
github 排序演算法是 資料結構與演算法 中最基本的演算法之一。排序演算法可以分為內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序演算法有 插入排序 希爾排序 選擇排序 氣泡排序 歸併排序...