用python排序算法_Python - 八大排序算法
1、序言
本文使用Python實現(xiàn)了一些常用的排序方法。文章結構如下：
1.直接插入排序
2.希爾排序
3.冒泡排序
4.快速排序
5.簡單選擇排序
6.堆排序
7.歸并排序
8.基數(shù)排序
上述所有的排序均寫在一個Python自定義類中，作為成員函數(shù)。
2、排序方法詳細介紹
1.直接插入排序
直接插入排序（Straight Insertion Sort）是一種最簡單的排序方法，它的基本操作是一個值插入到已排好序的有序表中，從而得到一個新的、記錄數(shù)增1的有序表。如下圖所示：
由上圖可知若最初始的有序表即為數(shù)組的第一個元素。用Python實現(xiàn)如下：
defstraight_insertion_sort(self, value_list):"""直接插入排序
:param value_list: 無序列表
:return:"""
return self.__straight_insert(value_list)
@staticmethoddef __straight_insert(value_list):
sorted_list=[]
sorted_list.append(value_list.pop(0))for i inrange(0, len(value_list)):
tail= True #是否在尾部插入
insert_loc =0for j inrange(len(sorted_list)):if value_list[i] <=sorted_list[j]:
tail=False
insert_loc=jbreaksorted_list.append(value_list[i])#先將值插入尾部
if nottail:#移動值
for j in range(len(sorted_list) - 1, insert_loc, -1):
temp=sorted_list[j]
sorted_list[j]= sorted_list[j - 1]
sorted_list[j- 1] =tempreturn sorted_list
2.希爾排序
希爾排序（Shell’s Sort）又稱“縮小增量排序”（Diminishing Incerement Sort），它也是一種數(shù)插入排序的方法，但在時間效率上較前面的排序方法有較大的改進。它的基本思想是：先將整個待排記錄序列分割成若干個子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行一次直接插入排序。如下圖所示：
即根據(jù)增量將原序列分割成多個子序列進行直接插入排序。增量應不斷減小，且最后一個增量為1。用Python實現(xiàn)如下：
defshells_sort(self, value_list):"""希爾排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""gap= len(value_list) // 2
while gap >= 1:
i=0while(i + gap)
start=i
gap_list=[]while start
gap_list.append(value_list[start])
start= start +gap
gap_list= self.__straight_insert(gap_list)
start=iwhile start
value_list[start]=gap_list.pop(0)
start+=gap
i+= 1gap//= 2sorted_list=value_listreturn sorted_list
3.冒泡排序
冒泡排序（Bubble Sort）的過程很簡單。首先將第一個記錄的關鍵字和第二個記錄的關鍵字進行比較，若逆序（與需要的順序相反），則將兩個記錄交換之，然后比較第二個記錄和第三個記錄的關鍵字，以此類推。為第一趟冒泡結束，接著對前n-1個記錄繼續(xù)進行上述的過程。這樣重復的過程直至n-1=1結束。排序過程如下所示：
用Python實現(xiàn)如下：
@staticmethoddefbubble_sort(value_list):"""冒泡排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""
for i in range(len(value_list) - 1):for j in range(i + 1, len(value_list)):if value_list[i] >value_list[j]:
value_list[i], value_list[j]=value_list[j], value_list[i]
sorted_list=value_listreturn sorted_list
4.快速排序
快速排序（Quick Sort）是對冒泡排序的一種改進。它的基本思想是，通過一趟排序將待排記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續(xù)進行排序，已達到整個序列有序。其排序思想如下：
首先任意選取一個記錄（通?？蛇x第一個記錄）作為樞軸，然后按下述原則重新排列記錄：將所有關鍵字較它小的記錄都安置在它的位置之前，將所有關鍵字較它大的記錄都安置在它的位置之后。一趟快速排序的具體做法是：設兩個指針low和high，他們的初值分別為最低位置的下一個位置和最高位，設最低位置樞軸的關鍵字為pivotkey，則首先從high所指位置起向前搜索找到第一個關鍵字小于pivotkey的記錄的樞軸記錄互相交換。發(fā)生了交換后才從low所指向的位置起向后搜索，找到第一個關鍵字大于pivotkey的記錄和樞軸記錄互相交換。重復這兩步直至low=how為止
如下圖所示：
特別要注意換方向的時機是發(fā)生了交換后，用Python實現(xiàn)如下：
defquick_sort(self, value_list):"""快速排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""low=0
high= len(value_list) - 1self.__qsort(value_list, low, high)
sorted_list=value_listreturnsorted_listdef __qsort(self, val_list, low, high):"""快速排序輔助函數(shù)
:param val_list: 無序列表
:param low: 低位
:param high: 高位
:return:"""
if low >=high:returnpivot_key=low
temp_low=pivot_key
temp_high=highwhile low
while low
temp=val_list[high]
val_list[high]=val_list[pivot_key]
val_list[pivot_key]=temp
pivot_key=highbreak #發(fā)生交換后，就換方向
else:
high-= 1
while low val_list[pivot_key]:
temp=val_list[low]
val_list[low]=val_list[pivot_key]
val_list[pivot_key]=temp
pivot_key=lowbreak #發(fā)生交換后，就換方向
else:
low+= 1self.__qsort(val_list, temp_low, pivot_key - 1)
self.__qsort(val_list, pivot_key + 1, temp_high)
5.簡單選擇排序
選擇排序（Selection Sort）是一種簡單直觀的排序算法。它的基本思想是：每一趟在n-i+1(i=1,2,...,n-1)個記錄中選取關鍵字最小的記錄作為有序序列中第i個記錄。簡單選擇排序：通過n-1次關鍵字的比較，從n-i+1個記錄中選出關鍵字最小的記錄，并和第i(1≤i≤n)個記錄交換之。如下圖所示：
用Python實現(xiàn)如下：
@staticmethoddefsimple_selection_sort(value_list):"""簡單選擇排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""
for i inrange(len(value_list)):
min_val= 9999999
for j inrange(i, len(value_list)):if min_val >value_list[j]:
min_val=value_list[j]
count= 0 #如果有多個相同的最小值
for j inrange(i, len(value_list)):if min_val ==value_list[j]:
value_list[j], value_list[i+ count] = value_list[i +count], value_list[j]
sorted_list=value_listreturn sorted_list
6.堆排序
堆排序（Heap Sort）是指利用堆這種數(shù)據(jù)結構所設計的一種排序算法。堆的定義如下：
n個元素的序列{k1,k2,...,kn}當且僅當滿足一下關系時，稱之為堆。
若將序列看成是一個完全二叉樹，則堆的含義表明，完全二叉樹中所有非終端節(jié)點均不大于（或不小于）其左、右孩子節(jié)點的值。由此，若序列是堆，則堆頂元素必為序列中的最小值（或最大值）。如下圖所示：
至此，我們可以給出堆排序的過程：若在輸出堆頂?shù)淖钚≈岛?#xff0c;使得剩余n-1個元素的序列又建成一個堆，則得到n個元素中的次小值。如此反復執(zhí)行，便能得到一個有序序列。
故整個堆排序可以大致分為兩個過程：
·將無序序列建成堆。
·輸出堆頂元素后，用類似建堆的方法調整堆。
如下兩個圖所示：
根據(jù)堆排序的特點總結出兩點注意事項：
1.利用把堆看成完全二叉樹的特點，用完全二叉樹的性質解決算法問題。
2.建堆的過程是從樹種的最后一個非終端節(jié)點逆序開始調整的。
3.每調整一次需要檢查前后是否依然保持堆的特征。
本文利用了二叉樹的孩子兄弟表示法來生成二叉樹（堆）的。代碼如下：
classCldSibNode(object):"""私有內部類：孩子兄弟二叉鏈表節(jié)點"""
def __init__(self, val):
self.value=val
self.child=None
self.sibling=Nonedefheap_sort(self, value_list):"""堆排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""sorted_list=[]
root_node=self.CldSibNode(None)
self.__child_sibling(root_node, value_list, 0)for ct in range(1, len(value_list) // 2 + 1): #建堆
self.__adjust_heap(root_node, len(value_list) // 2 + 1 - ct, 1)for i in range(1, len(value_list) + 1): #堆排序
sorted_list.append(root_node.value) #輸出堆頂元素
head =root_node
self.__shrink_heap(root_node, len(value_list) + 1 - i, 1, head)
self.__adjust_heap(root_node, 1, 1) #調整堆
returnsorted_listdef __child_sibling(self, node, value_list, ind):"""創(chuàng)建完全二叉樹的左孩子右兄弟二叉鏈表
:param node: 當前節(jié)點
:param value_list: 待排序的無序列表
:param ind:
:return:"""
if ind >=len(value_list):returnnode.value=value_list[ind]if ind * 2 + 1
node.child= self.CldSibNode(None) #孩子
self.__child_sibling(node.child, value_list, ind * 2 + 1)if ind * 2 + 2
node.child.sibling= self.CldSibNode(None) #兄弟
self.__child_sibling(node.child.sibling, value_list, ind * 2 + 2)def __adjust_heap(self, root_node, last_ind, now_ind):if not root_node or not root_node.child: #不為空且有孩子
return
if now_ind ==last_ind:#需要調整的非終端節(jié)點
temp =root_node
cg=Falsewhiletemp.child:if temp.value >temp.child.value:
temp.value, temp.child.value=temp.child.value, temp.value
cg= True #發(fā)生交換
iftemp.child.sibling:if temp.value >temp.child.sibling.value:ifcg:#如果發(fā)生過交換
temp.value, temp.child.value =temp.child.value, temp.value
temp.value, temp.child.sibling.value=temp.child.sibling.value, temp.value
temp=temp.child.siblingcontinue
else:ifcg:#如果發(fā)生過交換
temp =temp.childcontinue
break
#遞歸
self.__adjust_heap(root_node.child, last_ind, now_ind * 2)ifroot_node.child.sibling:
self.__adjust_heap(root_node.child.sibling, last_ind, now_ind * 2 + 1)def __shrink_heap(self, root_node, last_ind, now_ind, head):if not root_node or now_ind * 2 >last_ind:#為空
return
if last_ind == now_ind * 2 + 1:
head.value=root_node.child.sibling.value
root_node.child.sibling=NonereturnTrueif last_ind == now_ind * 2:
head.value=root_node.child.value
root_node.child=NonereturnTrueifroot_node.child:
self.__shrink_heap(root_node.child, last_ind, now_ind * 2, head)
self.__shrink_heap(root_node.child.sibling, last_ind, now_ind * 2 + 1, head)
7.歸并排序
歸并排序（Merging Sort），“歸并”的含義是將兩個或兩個以上的有序表組合成一個新的有序表。假設初始序列有n個記錄，則可看成是n個有序的子序列，每個子序列的長度為1，然后兩兩歸并，得到[n/2]個長度為2或1的有序子序列；再兩兩歸并，……，如此重復，直至得到一個長度為n的有序序列為止，這種排序方法為2-路歸并排序。算法的基本思想如下圖所示：
其中兩個子序列的合并大有學問，基本思想就是：分別在兩個序列頭設置指針，比較兩個序列指針所指的值的大小，將滿足要求的值提取出來形成新列表，并將指針右移。當其中一個指針指向結尾之后時，表示其中一個列表已取盡，接著直接在新列表尾部連接另一個列表。如下圖所示：
用Python實現(xiàn)如下：
@staticmethoddefmerging_sort(self, value_list):"""歸并排序
:param value_list: 待排序的無序列表
:return: 排序后的新列表"""i=0while np.power(2, i)
count= np.power(2, i)
start=0
outer_temp=[]while start
other = start +count
temp=[]if other >=len(value_list):#另一邊不存在：直接合并
outer_temp.extend(value_list[start: start +count])breakleft, right=0, 0while left < count or right =len(value_list):#右邊提前結束
temp.extend(value_list[start + left: start +count])break
elif value_list[start + left] < value_list[other +right]:#左邊更小
temp.append(value_list[start +left])
left+= 1
if left ==count:#左邊遍歷結束
temp.extend(value_list[other + right: other +count])break
else:#右邊更小
temp.append(value_list[other +right])
right+= 1
if right ==count:#右邊遍歷結束
temp.extend(value_list[start + left: start +count])breakouter_temp.extend(temp)
start+= count * 2value_list=outer_temp
i+= 1sorted_list=value_listreturn sorted_list
8.基數(shù)排序
基數(shù)排序（Radix Sort）是一種非比較整數(shù)排序算法，其原理是將整數(shù)按位數(shù)切割成不同的數(shù)字，然后按每個位數(shù)分別比較。由于整數(shù)也可以表達字符串（比如名字或日期）和特定格式的浮點數(shù)，所以基數(shù)排序也不是只能使用于整數(shù)。
排序時有兩點需要注意：
1.每完成一趟排序，要清空隊列。
2.隊列的連接要找到第一個不為空的隊列作為頭，和繞開所有空隊列。
用Python實現(xiàn)如下：
@staticmethoddefradix_sort(value_list):"""基數(shù)排序
:param value_list: 待排序的無序列表
:return: 排序后的新列表"""i=0
max_num=max(value_list)
n=len(str(max_num))while i
bucket_list = [[] for _ in range(10)]for x invalue_list:#找到位置放入桶數(shù)組
bucket_list[int(x / (10 ** i)) % 10].append(x)
value_list.clear()for x inbucket_list:#放回原序列
for y inx:
value_list.append(y)
i+= 1sorted_list=value_listreturn sorted_list
測試代碼：
編寫測試代碼運行結果如下：
if __name__ == '__main__':
li= list(np.random.randint(1, 1000, 30))
my_sort=MySort()print("original sequence:", li)print("*" * 100)print("1.straight_insertion_sort:", my_sort.straight_insertion_sort(li.copy()))print("2.shells_sort:", my_sort.shells_sort(li.copy()))print("3.bubble_sort:", my_sort.bubble_sort(li.copy()))print("4.quick_sort:", my_sort.quick_sort(li.copy()))print("5.simple_selection_sort:", my_sort.simple_selection_sort(li.copy()))print("6.heap_sort:", my_sort.heap_sort(li.copy()))print("7.merging_sort:", my_sort.merging_sort(li.copy()))print("8.radix_sort:", my_sort.radix_sort(li.copy()))
測試運行結果：
original sequence: [424, 381, 234, 405, 554, 742, 527, 876, 27, 904, 169, 566, 854, 448, 65, 508, 226, 477, 12, 670, 408, 520, 774, 99, 159, 565, 393, 288, 149, 711]****************************************************************************************************
1.straight_insertion_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]2.shells_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]3.bubble_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]4.quick_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]5.simple_selection_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]6.heap_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]7.merging_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]8.radix_sort: [12, 27, 65, 99, 149, 159, 169, 226, 234, 288, 381, 393, 405, 408, 424, 448, 477, 508, 520, 527, 554, 565, 566, 670, 711, 742, 774, 854, 876, 904]
總結
各個排序效率見下圖：
可以得出以下幾個結論：
1.從平均時間性能而言，快速排序最佳。
2.堆排序適用于n較大的數(shù)據(jù)。
3.基數(shù)排序是穩(wěn)定的，時間復雜度較大的簡單排序方法也是穩(wěn)定的。
4.穩(wěn)定性是由方法本身決定的。
5.沒有最好的排序方法，視情況而定。
#! /usr/bin/env python3#-*- coding:utf-8 -*-
#Author : MaYi#Blog : http://www.cnblogs.com/mayi0312/#Date : 2020-01-06#Name : mySort#Software : PyCharm#Note : 八大排序算法
importnumpy as npclassMySort(object):"""自定義一個排序的類"""
defstraight_insertion_sort(self, value_list):"""直接插入排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""
return self.__straight_insert(value_list)
@staticmethoddef __straight_insert(value_list):
sorted_list=[]
sorted_list.append(value_list.pop(0))for i inrange(0, len(value_list)):
tail= True #是否在尾部插入
insert_loc =0for j inrange(len(sorted_list)):if value_list[i] <=sorted_list[j]:
tail=False
insert_loc=jbreaksorted_list.append(value_list[i])#先將值插入尾部
if nottail:#移動值
for j in range(len(sorted_list) - 1, insert_loc, -1):
sorted_list[j], sorted_list[j- 1] = sorted_list[j - 1], sorted_list[j]returnsorted_listdefshells_sort(self, value_list):"""希爾排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""gap= len(value_list) // 2
while gap >= 1:
i=0while(i + gap)
start=i
gap_list=[]while start
gap_list.append(value_list[start])
start= start +gap
gap_list= self.__straight_insert(gap_list)
start=iwhile start
value_list[start]=gap_list.pop(0)
start+=gap
i+= 1gap//= 2sorted_list=value_listreturnsorted_list
@staticmethoddefbubble_sort(value_list):"""冒泡排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""
for i in range(len(value_list) - 1):for j in range(i + 1, len(value_list)):if value_list[i] >value_list[j]:
value_list[i], value_list[j]=value_list[j], value_list[i]
sorted_list=value_listreturnsorted_listdefquick_sort(self, value_list):"""快速排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""low=0
high= len(value_list) - 1self.__qsort(value_list, low, high)
sorted_list=value_listreturnsorted_listdef __qsort(self, val_list, low, high):"""快速排序輔助函數(shù)
:param val_list: 無序列表
:param low: 低位
:param high: 高位
:return:"""
if low >=high:returnpivot_key=low
temp_low=pivot_key
temp_high=highwhile low
while low
temp=val_list[high]
val_list[high]=val_list[pivot_key]
val_list[pivot_key]=temp
pivot_key=highbreak #發(fā)生交換后，就換方向
else:
high-= 1
while low val_list[pivot_key]:
temp=val_list[low]
val_list[low]=val_list[pivot_key]
val_list[pivot_key]=temp
pivot_key=lowbreak #發(fā)生交換后，就換方向
else:
low+= 1self.__qsort(val_list, temp_low, pivot_key - 1)
self.__qsort(val_list, pivot_key + 1, temp_high)
@staticmethoddefsimple_selection_sort(value_list):"""簡單選擇排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""
for i inrange(len(value_list)):
min_val= 9999999
for j inrange(i, len(value_list)):if min_val >value_list[j]:
min_val=value_list[j]
count= 0 #如果有多個相同的最小值
for j inrange(i, len(value_list)):if min_val ==value_list[j]:
value_list[j], value_list[i+ count] = value_list[i +count], value_list[j]
sorted_list=value_listreturnsorted_listclassCldSibNode(object):"""私有內部類：孩子兄弟二叉鏈表節(jié)點"""
def __init__(self, val):
self.value=val
self.child=None
self.sibling=Nonedefheap_sort(self, value_list):"""堆排序
:param value_list: 待排序的無序列表
:return: 排序后的列表"""sorted_list=[]
root_node=self.CldSibNode(None)
self.__child_sibling(root_node, value_list, 0)for ct in range(1, len(value_list) // 2 + 1): #建堆
self.__adjust_heap(root_node, len(value_list) // 2 + 1 - ct, 1)for i in range(1, len(value_list) + 1): #堆排序
sorted_list.append(root_node.value) #輸出堆頂元素
head =root_node
self.__shrink_heap(root_node, len(value_list) + 1 - i, 1, head)
self.__adjust_heap(root_node, 1, 1) #調整堆
returnsorted_listdef __child_sibling(self, node, value_list, ind):"""創(chuàng)建完全二叉樹的左孩子右兄弟二叉鏈表
:param node: 當前節(jié)點
:param value_list: 待排序的無序列表
:param ind:
:return:"""
if ind >=len(value_list):returnnode.value=value_list[ind]if ind * 2 + 1
node.child= self.CldSibNode(None) #孩子
self.__child_sibling(node.child, value_list, ind * 2 + 1)if ind * 2 + 2
node.child.sibling= self.CldSibNode(None) #兄弟
self.__child_sibling(node.child.sibling, value_list, ind * 2 + 2)def __adjust_heap(self, root_node, last_ind, now_ind):if not root_node or not root_node.child: #不為空且有孩子
return
if now_ind ==last_ind:#需要調整的非終端節(jié)點
temp =root_node
cg=Falsewhiletemp.child:if temp.value >temp.child.value:
temp.value, temp.child.value=temp.child.value, temp.value
cg= True #發(fā)生交換
iftemp.child.sibling:if temp.value >temp.child.sibling.value:ifcg:#如果發(fā)生過交換
temp.value, temp.child.value =temp.child.value, temp.value
temp.value, temp.child.sibling.value=temp.child.sibling.value, temp.value
temp=temp.child.siblingcontinue
else:ifcg:#如果發(fā)生過交換
temp =temp.childcontinue
break
#遞歸
self.__adjust_heap(root_node.child, last_ind, now_ind * 2)ifroot_node.child.sibling:
self.__adjust_heap(root_node.child.sibling, last_ind, now_ind * 2 + 1)def __shrink_heap(self, root_node, last_ind, now_ind, head):if not root_node or now_ind * 2 >last_ind:#為空
return
if last_ind == now_ind * 2 + 1:
head.value=root_node.child.sibling.value
root_node.child.sibling=NonereturnTrueif last_ind == now_ind * 2:
head.value=root_node.child.value
root_node.child=NonereturnTrueifroot_node.child:
self.__shrink_heap(root_node.child, last_ind, now_ind * 2, head)
self.__shrink_heap(root_node.child.sibling, last_ind, now_ind * 2 + 1, head)
@staticmethoddefmerging_sort(value_list):"""歸并排序
:param value_list: 待排序的無序列表
:return: 排序后的新列表"""i=0while np.power(2, i)
count= np.power(2, i)
start=0
outer_temp=[]while start
other = start +count
temp=[]if other >=len(value_list):#另一邊不存在：直接合并
outer_temp.extend(value_list[start: start +count])breakleft, right=0, 0while left < count or right =len(value_list):#右邊提前結束
temp.extend(value_list[start + left: start +count])break
elif value_list[start + left] < value_list[other +right]:#左邊更小
temp.append(value_list[start +left])
left+= 1
if left ==count:#左邊遍歷結束
temp.extend(value_list[other + right: other +count])break
else:#右邊更小
temp.append(value_list[other +right])
right+= 1
if right ==count:#右邊遍歷結束
temp.extend(value_list[start + left: start +count])breakouter_temp.extend(temp)
start+= count * 2value_list=outer_temp
i+= 1sorted_list=value_listreturnsorted_list
@staticmethoddefradix_sort(value_list):"""基數(shù)排序
:param value_list: 待排序的無序列表
:return: 排序后的新列表"""i=0
max_num=max(value_list)
n=len(str(max_num))while i
bucket_list = [[] for _ in range(10)]for x invalue_list:#找到位置放入桶數(shù)組
bucket_list[int(x / (10 ** i)) % 10].append(x)
value_list.clear()for x inbucket_list:#放回原序列
for y inx:
value_list.append(y)
i+= 1sorted_list=value_listreturnsorted_listif __name__ == '__main__':
li= list(np.random.randint(1, 1000, 30))
my_sort=MySort()print("original sequence:", li)print("*" * 100)print("1.straight_insertion_sort:", my_sort.straight_insertion_sort(li.copy()))print("2.shells_sort:", my_sort.shells_sort(li.copy()))print("3.bubble_sort:", my_sort.bubble_sort(li.copy()))print("4.quick_sort:", my_sort.quick_sort(li.copy()))print("5.simple_selection_sort:", my_sort.simple_selection_sort(li.copy()))print("6.heap_sort:", my_sort.heap_sort(li.copy()))print("7.merging_sort:", my_sort.merging_sort(li.copy()))print("8.radix_sort:", my_sort.radix_sort(li.copy()))
完整代碼
總結
以上是生活随笔為你收集整理的用python排序算法_Python - 八大排序算法的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 草鱼鳔的功效与作用、禁忌和食用方法
- 下一篇： cv2.imread读取图像结果none