#工具人排序

def?nums_sort(data):

if?not?data:

return?[]

min_data?=?min(data)

max_data?=?max(data)

nums?=?[0]*(max_data-min_data+1)

for?value?in?data:

nums[value-min_data]+=1

cur?=?min_data

for?index?in?range?(len(data)):

while?cur<=?max_data?and?nums[cur-min_data]<=0:

cur+=1

nums[cur-min_data]-=1

data[index]?=?cur

return?data

print(nums_sort(old_data[:]))

def?bucket_sort(data,K?=?10):

if?not?data:

return

#K桶的大小?桶的大小?=?data的范圍時，就一個桶，可以退化為計數排序

if?K<=0:

K?=?10

min_data?=?min(data)

max_data?=?max(data)

#//K向下取整，需要多補一個，計數排序返回空[]才可以用extend函數

buckets?=?[[]?for?_?in?range(1+(max_data-min_data)//K)]

for?value?in?data:

buckets[(value-min_data)//K].append(value)

res?=?[]

for?i?in?buckets:

res.extend(nums_sort(i))

return?res

print(bucket_sort(old_data[:],K=2))

補充了排序彩蛋，我自己留著也沒用。

#排序

old_data?=?[1,6,2,8,3,7,4,5,9]

#1選擇排序，不穩定

#每次選擇最小的與當前的開頭交換

#時間O(1),O(n^2),O(n^2),空間O(1)

def?selection_sort(data):

for?st_index?in?range(len(data)):

min_data?=?data[st_index]

min_index?=?st_index

#最小值搜索

for?j?in?range(st_index+1,len(data)):

if?min_data>=data[j]:

min_data?=?data[j]

min_index?=?j

data[st_index],data[min_index]=data[min_index],data[st_index]

print(data)

selection_sort(old_data[:])

#2插入排序，穩定

#將當前數值插入到前面位置有序數組

#時間O(1),O(n^2),O(n^2),空間O(1)

def?insert_sort(data):

for?cur_index?in?range(1,len(data)):

cur_data?=?data[cur_index]

#插入

for?j?in?range(cur_index,0,-1):

#如果后面的base數值比前面一個小，交換

#一直交換到大于前面的就好了

if?cur_data>=data[j-1]:

break

data[j-1],data[j]=data[j],data[j-1]

print(data)

insert_sort(old_data[:])

#3希爾排序，不穩定

#插入快排的優化，插入要一個一個移動，希爾排序定義了數據間隔，從大到小，根據間隔插入

#適用性強，適合當base

#時間O(n),O(n^1.3-2),O(n^2),空間O(1)

def?shell_sort(data,k=3):

d?=?1

while?d

d*=k

d+=1

while?d>=1:

#正常的插入排序，間隔改成了由1改成d

for?cur_index?in?range(d,len(data)):

cur_data?=?data[cur_index]

for?j?in?range(cur_index,d-1,-d):

if?cur_data>=data[j-d]:

break

data[j-d],data[j]=data[j],data[j-d]

d//=k

print(data)

shell_sort(old_data[:])

#歸并排序，穩定

#時間O(nlog(n)),O(nlog(n)),O(nlog(n)),空間O(n)

#全局數組寫法，實際上開臨時數組寫法更簡略，空間復雜度都是O(n),主要擔心頻繁開小空間浪費時間，可讀性不如后者

def?merge(data,l1,r1,l2,r2,data_help):

cur_index?=?0

t_l1,t_l2=l1,l2

while(l1<=r1?and?l2<=r2):

if?data[l1]<=data[l2]:

data_help[cur_index],cur_index,l1,=data[l1],cur_index+1,l1+1

else:

data_help[cur_index],cur_index,l2=data[l2],cur_index+1,l2+1

while(l1<=r1):

data_help[cur_index],cur_index,l1,=data[l1],cur_index+1,l1+1

while(l2<=r2):

data_help[cur_index],cur_index,l2=data[l2],cur_index+1,l2+1

l1,l2=t_l1,t_l2

for?index?in?range(r1-l1+1):

data[l1+index]=data_help[index]

for?index?in?range(r2-l2+1):

data[l2+index]=data_help[index+r1-l1+1]

def?merge_sort(data,st?=?None,en?=?None):

if?not?data:

return?None

if?st?is?None:

st?=?0

if?en?is?None:

en?=?len(data)-1

merge_sort_help(data,st,en,[0]*(en-st+1))

def?merge_sort_help(data,st,en,data_help):

if?st?

mid?=?st?+?(en-st)//2

merge_sort_help(data,st,mid,data_help)

merge_sort_help(data,mid+1,en,data_help)

merge(data,st,mid,mid+1,en,data_help)

#非遞歸,每次相鄰合并一下即可，步長從1自增

def?merge_bottom(data,st?=?None,en?=?None):

if?not?data:

return?None

if?st?is?None:

st?=?0

if?en?is?None:

en?=?len(data)-1

step?=?1

data_help?=?[0]*(en-st+1)

while?step<=en-st+1:

for?left?in?range(st,en-step+1,2*step):

l1,r1,l2,r2?=?left,left+step-1,left+step,left+2*step-1

if?r2>en:

r2=en

merge(data,l1,r1,l2,r2,data_help)

step*=2

print(data)

merge_sort(old_data[:])

merge_bottom(old_data[:])

#快排，不穩定

#時間O(nlog(n)),O(nlog(n)),O(n^2),空間O(1)

#快排的優點就是快，主要是數據量比較大的時候

#三路快排

def?q_sort(data,st=None,en=None):

if?not?data:

return

if?st?is?None:

st?=?0

if?en?is?None:

en?=?len(data)-1

if?st>=en:

return

import?random

index?=?random.randint(st,en)

data[index],data[st]=data[st],data[index]

l,r?=?st+1,en

base?=?data[st]

#base的邊界為r

index?=?st

while?l<=r:

#左端點比叫base，小值則交換base和當前左端點，大值則當前左端點和尾端交換

#index代表了小于base的分界線，r代表大于base的分界線

if?data[l]

data[index],data[l],index,l=data[l],data[index],index+1,l+1

continue

if?data[l]>base:

data[l],data[r],r=data[r],data[l],r-1

continue

l+=1

q_sort(data,st,index-1)

q_sort(data,r+1,en)

return?data

#非遞歸,展開即可，由于區域不想交，可以隨機改順序，只要排序范圍逐漸減少就行

def?q_sort_bottom(data,st=None,en=None):

if?not?data:

return

if?st?is?None:

st?=?0

if?en?is?None:

en?=?len(data)-1

if?st>=en:

return

import?queue

q?=?queue.Queue()

q.put((st,en))

while(q.empty()==False):

cur?=?q.get()

st,en?=?cur[0],cur[1]

import?random

index?=?random.randint(st,en)

data[index],data[st]=data[st],data[index]

l,r?=?st+1,en

base?=?data[st]

index?=?st

while?l<=r:

#左端點比叫base，小值則交換base和當前左端點，大值則當前左端點和尾端交換

if?data[l]

data[index],data[l],index,l=data[l],data[index],index+1,l+1

continue

if?data[l]>base:

data[l],data[r],r=data[r],data[l],r-1

continue

l+=1

if?st

q.put((st,index-1))

if?r+1

q.put((r+1,en))

return?data

print(q_sort(old_data[:]))

print(q_sort_bottom(old_data[:]))

#堆排序，不穩定

#時間O(nlog(n)),O(nlog(n)),O(nlog(n)),空間O(n)

#建堆O(n),但是順序要從堆中一個個彈出，這一步是O(nlog(n))

#更新調整操作

#小值在前用大頂堆

def?heap_adj(data,index):

if?not?data:

return

if?index<0?or?index>=len(data):

return

l,r?=?index*2+1,index*2+2

cur?=?index

if?l

cur?=?l

if?r

cur?=?r

if?cur!=index:

data[index],data[cur]=data[cur],data[index]

heap_adj(data,cur)

return

#原地建堆

def?make_heap(data):

for?index?in?range(len(data)//2,-1,-1):

heap_adj(data,index)

heap?=?data

return?heap

def?heap_updata(heap,value):

if?heap?is?None:

return

if?value

heap[0]=value

heap_adj(heap,0)

def?heap_delete(heap):

if?heap?is?None:

return

heap[0]=heap[-1]

heap.pop()

heap_adj(heap,0)

def?heap_add(heap,value):

heap.append(value)

index?=?len(heap)-1

next_index?=?(index-1)//2

while?index!=next_index?and?index>=0:

if?data[index]>data[next_index]:

data[index],data[next_index]=data[next_index],data[index]

index,next_index=next_index,(next_index-1)//2

continue

else:

break

return

def?heap_sort(data):

heap?=?make_heap(data[:])

#大頂堆

times?=?len(heap)

res?=?[0]*times

for?index?in?range(times-1,-1,-1):

res[index]=heap[0]

heap_delete(heap)

return?res

print(heap_sort(old_data[:]))

#桶排序?=?分段計數排序

#計數排序，統計各個元素的數目

def?nums_sort(data):

if?not?data:

return?[]

min_data?=?min(data)

max_data?=?max(data)

nums?=?[0]*(max_data-min_data+1)

for?value?in?data:

nums[value-min_data]+=1

cur?=?min_data

for?index?in?range?(len(data)):

while?cur<=?max_data?and?nums[cur-min_data]<=0:

cur+=1

nums[cur-min_data]-=1

data[index]?=?cur

return?data

print(nums_sort(old_data[:]))

def?bucket_sort(data,K?=?10):

if?not?data:

return

#K桶的大小?桶的大小?=?data的范圍時，就一個桶，可以退化為計數排序

if?K<=0:

K?=?10

min_data?=?min(data)

max_data?=?max(data)

#//K向下取整，需要多補一個，計數排序返回空[]才可以用extend函數

buckets?=?[[]?for?_?in?range(1+(max_data-min_data)//K)]

for?value?in?data:

buckets[(value-min_data)//K].append(value)

res?=?[]

for?i?in?buckets:

res.extend(nums_sort(i))

return?res

print(bucket_sort(old_data[:],K=2))

總結

以上是生活随笔為你收集整理的python链表排序_链表排序+末尾各种排序的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。