排序python代码_算法_python各种排序的代码实现

python各种排序的代码实现

冒泡排序

# 冒泡排序

def bubbleSort(alist):

for passnum in range(len(alist)-1, 0, -1):

for i in range(passnum):

if alist[i] > alist[i + 1]:

temp = alist[i]

alist[i] = alist[i + 1]

alist[i + 1] = temp

return alist

选择排序

# 选择排序

def selectSort(alist):

for fillslot in range(len(alist) - 1, 0, -1):

positionOfMax = 0

for location in range(1, fillslot + 1):

if alist[location] > alist[positionOfMax]:

positionOfMax = location

if positionOfMax != fillslot:

alist[fillslot], alist[positionOfMax] = alist[positionOfMax], alist[fillslot]

return alist

alist = [4, 8, 1, 9, 2, 0, 3, 7, 5, 6]

print(selectSort(alist))

插入排序

# 插入排序

def insertSort(alist):

for index in range(len(alist)):

currentvalue = alist[index]

position = index

while position > 0 and alist[position - 1] > currentvalue:

alist[position] = alist[position - 1]

position = position - 1

alist[position] = currentvalue

return alist

alist = [4, 8, 1, 9, 2, 0, 3, 7, 5, 6]

print(insertionSort(alist))

希尔排序

# 希尔排序

def shellSort(alist):

sublistcount = len(alist) // 2

while sublistcount > 0:

for startposition in range(sublistcount):

gapinsertionSort(alist, startposition, sublistcount)

print("After increments of size", sublistcount, "Then list is", alist)

sublistcount = sublistcount // 2

return alist

def gapinsertionSort(alist, start, gap):

for i in range(start+gap, len(alist), gap):

currentvalue = alist[i]

position = i

while position >= gap and alist[position - gap] > currentvalue:

alist[position] = alist[position - gap]

position = position - gap

alist[position] = currentvalue

alist = [4, 8, 1, 9, 2, 0, 3, 7, 5, 6]

print(shellSort(alist))

归并排序

# 归并排序--递归实现

def mergeSort(alist=[]):

if len(alist) <= 1:

return alist

else:

mid = len(alist) // 2

left = []

right = []

left = mergeSort(alist[:mid])

right = mergeSort(alist[mid:])

return merge(left, right)

def merge(left=[], right=[]):

# i, j are index for left and right seperately

i, j = 0, 0

result = []

while i < len(left) and j < len(right):

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

result.append(left[i])

i += 1

else:

result.append(right[j])

j += 1

# 将剩余部分依次加入 result

result = result + left[i:]

result = result + right[j:]

return result

alist = [4, 8, 1, 9, 2, 0, 3, 7, 5, 6]

print(mergeSort(alist))

快速排序

# 快速排序

def quicksort(collection):

length = len(collection)

if length <= 1:

return collection

else:

# Use the last element as the first pivot

pivot = collection.pop()

# Put elements greater than pivot in greater list

# Put elements lesser than pivot in lesser list

greater, lesser = [], []

for element in collection:

if element > pivot:

greater.append(element)

else:

lesser.append(element)

return quicksort(lesser) + [pivot] + quicksort(greater)

if __name__ == '__main__':

list1 = [7, 3, 23, 6, 9, 9, 10]

res = quicksort(list1)

print(res)

堆排序

本段代码来自github

def heapify(unsorted, index, heap_size):

"""制作一个大根堆"""

largest = index

left_index = 2 * index + 1 # 左子节点的索引位置

right_index = 2 * index + 2 # 右子节点的索引位置

if left_index < heap_size and unsorted[left_index] > unsorted[largest]: # 存在左子节点并且左子节点大于父节点

largest = left_index # 最大节点的索引为 左子节点的索引

if right_index < heap_size and unsorted[right_index] > unsorted[largest]: # 存在右子节点并且右子节点的值大于左子节点的值

largest = right_index # 最大节点的索引为 右子节点的索引

if largest != index: # 最大值索引 不是 父节点的索引

unsorted[largest], unsorted[index] = unsorted[index], unsorted[largest] # 将父节点和左右节点中的较大者互换位置

heapify(unsorted, largest, heap_size) # 递归的整理树的节点

def heap_sort(unsorted):

n = len(unsorted)

for i in range(n//2 - 1, -1, -1): # 建立初始大根堆

heapify(unsorted, i, n)

print(unsorted)

for i in range(n - 1, 0, -1): # 在原有列表的基础上，将每次大根堆的最大值和最尾部节点做交换，

# print(f"===>{i}")

unsorted[0], unsorted[i] = unsorted[i], unsorted[0]

heapify(unsorted, 0, i) # 重新整理剩下的节点为大根堆

return unsorted

if __name__ == '__main__':

unsorted = [3, 1, 9, 4, 2, 7, 5, 8, 6, 0]

print(heap_sort(unsorted))