1、插入排序

def?insert_sort(lists):

#?插入排序

count?=?len(lists)

for?i?in?range(1,?count):

key?=?lists[i]

j?=?i?-?1

while?j?>=?0:

if?lists[j]?>?key:

lists[j?+?1]?=?lists[j]

lists[j]?=?key

j?-=?1

return?lists

2、希爾排序

def?shell_sort(lists):

#?希爾排序

count?=?len(lists)

step?=?2

group?=?count?/?step

while?group?>?0:

for?i?in?range(0,?group):

j?=?i?+?group

while?j?

k?=?j?-?group

key?=?lists[j]

while?k?>=?0:

if?lists[k]?>?key:

lists[k?+?group]?=?lists[k]

lists[k]?=?key

k?-=?group

j?+=?group

group?/=?step

return?lists

3、冒泡排序

def?bubble_sort(lists):

#?冒泡排序

count?=?len(lists)

for?i?in?range(0,?count):

for?j?in?range(i?+?1,?count):

if?lists[i]?>?lists[j]:

lists[i],?lists[j]?=?lists[j],?lists[i]

return?lists

4、快速排序

def?quick_sort(lists,?left,?right):

#?快速排序

if?left?>=?right:

return?lists

key?=?lists[left]

low?=?left

high?=?right

while?left?

while?left?=?key:

right?-=?1

lists[left]?=?lists[right]

while?left?

left?+=?1

lists[right]?=?lists[left]

lists[right]?=?key

quick_sort(lists,?low,?left?-?1)

quick_sort(lists,?left?+?1,?high)

return?lists

5、直接選擇排序

def?select_sort(lists):

#?選擇排序

count?=?len(lists)

for?i?in?range(0,?count):

min?=?i

for?j?in?range(i?+?1,?count):

if?lists[min]?>?lists[j]:

min?=?j

lists[min],?lists[i]?=?lists[i],?lists[min]

return?lists

6、堆排序

#?調整堆

def?adjust_heap(lists,?i,?size):

lchild?=?2?*?i?+?1

rchild?=?2?*?i?+?2

max?=?i

if?i?

if?lchild??lists[max]:

max?=?lchild

if?rchild??lists[max]:

max?=?rchild

if?max?!=?i:

lists[max],?lists[i]?=?lists[i],?lists[max]

adjust_heap(lists,?max,?size)

#?創建堆

def?build_heap(lists,?size):

for?i?in?range(0,?(size/2))[::-1]:

adjust_heap(lists,?i,?size)

#?堆排序

def?heap_sort(lists):

size?=?len(lists)

build_heap(lists,?size)

for?i?in?range(0,?size)[::-1]:

lists[0],?lists[i]?=?lists[i],?lists[0]

adjust_heap(lists,?0,?i)

7、歸并排序

def?merge(left,?right):

i,?j?=?0,?0

result?=?[]

while?i?

if?left[i]?<=?right[j]:

result.append(left[i])

i?+=?1

else:

result.append(right[j])

j?+=?1

result?+=?left[i:]

result?+=?right[j:]

return?result

def?merge_sort(lists):

#?歸并排序

if?len(lists)?<=?1:

return?lists

num?=?len(lists)?/?2

left?=?merge_sort(lists[:num])

right?=?merge_sort(lists[num:])

return?merge(left,?right)

8、基數排序

import?math

def?radix_sort(lists,?radix=10):

k?=?int(math.ceil(math.log(max(lists),?radix)))

bucket?=?[[]?for?i?in?range(radix)]

for?i?in?range(1,?k+1):

for?j?in?lists:

bucket[j/(radix**(i-1))?%?(radix**i)].append(j)

del?lists[:]

for?z?in?bucket:

lists?+=?z

del?z[:]

return?lists

總結

以上是生活随笔為你收集整理的python 八大排序_八大排序算法的 Python 实现的全部內容，希望文章能夠幫你解決所遇到的問題。

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