常用排序演算法總結

實現稍微難點的三個演算法：快排、歸併、堆排序

快速排序

以下是一種寫法（演算法導論上是另一種寫法，待補充）

def quicksort(data, start, end):

i = start
j = end
# i與j重合,一次排序結束
if i >= j:
return
# 設定最左邊的數為基準值
flag = data[start]
while i < j:
while i < j and data[j] >= flag:
j -= 1
# 找到右邊第乙個小於基準的數賦值給左邊i（此時左邊i被記錄在flag中）
data[i] = data[j]
while i < j and data[i] <= flag:
i += 1
# 找到左邊第乙個大於基準的數賦值給右邊的j
data[j] = data[i]
# 迴圈完後把flag值放到i所在位置
data[i] = flag
# print(data)
# 除去i之外兩段遞迴
quicksort(data, start, i - 1)
quicksort(data, i + 1, end)
if __name__ == "__main__":
data = [6, 5, 8, 2, 3, 1]
print(data)
quicksort(data, 0, len(data) - 1)
print(data)

def bubblesort(alist):

n = len(alist)
exchange = false
for i in range(n-1, 0, -1):
for j in range(0, i):
if alist[j] > alist[j+1]:
alist[j], alist[j+1] = alist[j+1], alist[j]
exchange = true
# 如果發現整個排序過程中沒有交換，提前結束
if not exchange:
break
return alist

def selectionsort(alist):

n = len(alist)
for i in range(n - 1):
# 尋找[i,n]區間裡的最小值
min_index = i
for j in range(i+1, n):
if alist[j] < alist[min_index]:
min_index = j
alist[i], alist[min_index] = alist[min_index], alist[i]
return alist

def insertionsort(blist):

n = len(blist)
for i in range(1, n):
# 尋找a[i]合適的插入位置
temp = blist[i]
for j in range(i, 0, -1):
if temp < blist[j-1]:
blist[j] = blist[j-1]
else:
break
blist[j-1] = temp
print(blist)
return blist

def shell1sort(data):

step = len(data) // 2
while step >= 1:
print("當前增量是：", step)
for i in range(step, len(data)):
for j in range(i-step, -step, -step):
if data[j] > data[j+step]:
data[j], data[j+step] = data[j+step], data[j]
step = int(step/2)

def merge_sort(nums):

if len(nums) <= 1:
return nums
middle = len(nums) // 2
left_num = nums[:middle]
right_num = nums[middle:]
return merge(merge_sort(left_num), merge_sort(right_num))
def merge(left_num, right_num):
len_left = len(left_num)
len_right = len(right_num)
i = j = 0
result = 
# 比較left_num和left_right中的元素，按序新增到result中
while i < len_left and j < len_right:
if left_num[i] > right_num[j]:
j += 1
else:
i += 1
# 將j中的剩餘元素新增到result中
if i == len_left and j < len_right:
for m in right_num[j:]:
# 將i中的剩餘元素新增到result中
if j == len_right and i < len_left:
for m in left_num[i:]:
return result

from collections import deque

# python中交換兩個元素的位置
def swap(nums, i, j):
nums[i], nums[j] = nums[j], nums[i]
return nums
# 構造最大堆
def heap_adjust(nums, start, end):
temp = nums[start]
i = start
j = start * 2
while j <= end:
if j < end and nums[j] < nums[j + 1]:
j += 1
if temp < nums[j]:
nums[i] = nums[j]
i = j
j = i * 2
else:
break
nums[i] = temp
# 堆排序
def heap_sort(nums):
len_heap = len(nums) - 1
len_mid_heap = len_heap // 2
# 將序列調整為乙個最大堆
for i in range(len_mid_heap):
heap_adjust(nums, len_mid_heap-i, len_heap)
print(nums)
# 將堆頂元素和堆末尾元素交換，將剩下元素調整為乙個最大對
for i in range(len_heap-1):
swap(nums, len_heap-i, 1)
heap_adjust(nums, 1, len_heap-i-1)
print(nums)
return list(nums)[1:]
def main():
l = deque([50, 16, 30, 10, 60, 90, 2, 80, 70])
print(heap_sort(l))

常用排序演算法總結

總結些常見的排序演算法，方便以後可以重用。資料量不大，為了表達方便就直接使用了陣列。int data null data new int 1.氣泡排序 氣泡排序,從小到大排序 for int i 0 i data.length i 氣泡排序就是說，排序的過程像水裡往上冒的氣泡一樣，每個數字代表乙個氣...

常用排序演算法總結

常用排序演算法總結 選擇排序 對於長度為n的陣列，選擇排序需要大約n2 2詞比較和n次交換。插入排序 對於隨機排列的長度為n且主鍵不重複的陣列 1 平均情況下，需要 n2 4次比較以及 n2 4次交換。2 最壞情況下，需要 n2 2次比較以及 n2 2次交換 3 最好情況下，需要n 1次比較以及0次...

常用排序演算法總結

注 所有排序都是寫的由小到大排序的情況 1.插入排序 1 直接插入排序 穩定 arr sortedindex 1 key 注意這裡的下標 sortedindex 1 2 希爾排序 不穩定 希爾排序好的增量序列的共同特徵 希爾排序演算法 fromid 1801475 type syn 最後乙個增量必須...