冒泡排序
def mp_sort(arr):
'''
冒泡排序
'''
for i in range(0,len(arr)-1):
for j in range(0,len(arr)-1-i):
if arr[j] > arr[j+1]:
arr[j],arr[j+1] = arr[j+1],arr[j]
選擇排序
def sel_sort(arr):
'''
選擇排序
'''
for i in range(0,len(arr)-1):
x,min_ = i,arr[i]
for j in range(i+1,len(arr)):
if arr[j] < min_:
x = j
min_ = arr[j]
arr[i],arr[x] = arr[x],arr[i]
插入排序
def insert_sort(arr):
'''
插入排序
'''
for i in range(1,len(arr)):
val = arr[i]
j = i-1
while j > -1 and val <= arr[j]:
arr[j+1] = arr[j]
j -= 1
arr[j+1] = val
希爾排序
def shell_sort(arr):
'''
希爾排序
'''
#先獲得遞減的增量
a,shell = len(arr),[]
while a > 1:
a //= 2
shell.append(a)
#print(shell)
#i選擇shell的值
for i in shell:
#j選擇要進行插入的值
for j in range(i,len(arr)):
val = arr[j]
k = j-i #k爲左邊的插入列表
while k > -1 and val < arr[k]:
arr[k+i] = arr[k]
k -= i
arr[k+i] = val
print(f'{i}排序完之後:{arr}')
歸併排序
def Merge_sort(arr):
'''
歸併排序，分治
'''
if len(arr) == 1:
return arr
mid = len(arr) // 2
left = Merge_sort(arr[:mid])
right = Merge_sort(arr[mid:])
return merge(left,right)
def merge(left,right):
'''
歸併排序的合併步驟
'''
#print(f'此時的left{left},right:{right}')
a = []
while len(left)>0 and len(right)>0:
if left[0] < right[0]:
a.append(left.pop(0))
else:
a.append(right.pop(0))
if len(left) > 0:
a.extend(left)
if len(right) > 0:
a.extend(right)
#print(f'a的值:',a)
return a
快速排序
兩個都是，只是實現方法不一樣
def quick_sort(arr):
'''
快速排序,分治
'''
#有可能有空列表的情況，如列表中的值全部爲大於a[0]的則，left就爲[]
if len(arr) <= 1:
return arr
a = arr[0]
left,right = [],[]
for i in range(1,len(arr)):
if arr[i] > a:
right.append(arr[i])
else:
left.append(arr[i])
return quick_sort(left) + [a] + quick_sort(right)
def quick_sort2(arr):
'''
快速排序，分治
'''
if len(arr) <= 1:
return arr
mid = 0
i = 0
while i < len(arr):
if arr[i] < arr[mid] and i > mid:
arr[i],arr[mid] = arr[mid],arr[i]
mid,i = i,mid
if arr[i] > arr[mid] and i < mid:
arr[i],arr[mid] = arr[mid],arr[i]
mid,i = i,mid
i += 1
print(f'左邊結果:{arr[:mid]},中間:{arr[mid]},右邊:{arr[mid+1:]}')
return quick_sort2(arr[:mid]) + [arr[mid]] + quick_sort2(arr[mid+1:])
堆排序
def heapify(arr,n,i):
'''
調整堆
'''
largest = i
l = 2*i + 1
r = 2*i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i]
heapify(arr,n,largest)
def heapSort(arr):
'''
堆排序
'''
n = len(arr)
#構建最大堆
for i in range(n,-1,-1):
heapify(arr,n,i)
#然後把最後一個元素和第一個元素交換位置，然後在除了最後一個位置的剩餘空間，重新構建最大堆,類推，知道第一個元素，結果就爲升序排序
for i in range(n-1,0,-1):
arr[i],arr[0] = arr[0],arr[i]
heapify(arr,i,0)
計數排序
def count_sort(arr):
'''
計數排序
'''
min_,max_ = min(arr),max(arr)
base = max_ - min_ + 1 #確定列表需要多少項目
temp = [0 for i in range(base)]
#添加的計數l用的列表
for i in arr:
temp[i-min_] += 1
#返回到結果
rel = []
for i in range(len(temp)):
while temp[i] > 0:
rel.append(i+min_)
temp[i] -= 1
return rel
桶排序
def BucketSort(arr):
'''
桶排序
'''
min_,max_ = min(arr),max(arr)
base = 5
index_base = max_//5
#創建桶列表，裏面是5個空列表，表示對應索引的桶
a = [[] for i in range(base+1)]
for i in arr:
a[i//index_base].append(i)
#對每個桶裏面的元素進行排序，可以使用任意其他的排序
for i in range(len(a)):
if len(a[i]) <= 1:
continue
a[i] = count_sort(a[i])
#輸出每個桶
print(f'現在桶裏是這樣的:{a}')
#合併每個桶，放入到結果列表中
rel = []
for i in a:
rel.extend(i)
return rel
基數排序
def RadixSort(arr):
'''
基數排序
'''
max_ = max(arr)
max_bit = len(str(max_)) #獲得最大值有多少位
radix = arr #存儲根據哪個位數來存儲s的數組
temp = [[] for i in range(10)] #臨時存儲s的
for i in range(max_bit):
#根據位數來排序(即比較個位，十位等,放在temp
for j in radix:
a = j//10**i % 10
temp[a].append(j)
#把排序的一次結果，存到radix中
radix = [] #先重置一下
for k in temp:
radix.extend(k)
temp = [[] for i in range(10)] #重新恢復
print(f'第{i}位數，排序後結果:{radix}')
return radix