演算法
平均複雜度
最壞情況
原地排序
額外空間
是否穩定
選擇排序
o(n 2n^
n2)o(n2n^
n2)是
o(1)
是氣泡排序
o(n 2n^
n2)o(n2n^
n2)是
o(1)
是插入排序
o(n 2n^
n2)o(n2n^
n2)是
o(1)
是歸併排序
o(n lo
gn
nlogn
nlogn)
o(n lo
gn
nlogn
nlogn)
否o(n)
是快速排序
o(n lo
gn
nlogn
nlogn)
o(n 2n^
n2)是
o(logn)
否堆排序
o(n lo
gn
nlogn
nlogn)
o(n lo
gn
nlogn
nlogn)
是o(1)
否值得注意的是：
插入排序對於近乎有序陣列效能比較好，最好的情況達到o(n)。
快排是幾種nlogn級別裡面最快的演算法
當陣列元素有很多重複的時，使用三路快排比較有優勢
1. 選擇排序
#選擇排序
def selectionsort(arr):
for i in range(len(arr)-1):
min_index = i
for j in range(i+1, len(arr)):
if arr[j]2 . 氣泡排序
#氣泡排序
def bubblesort(arr):
for i in range(len(arr)-1):
for j in range(len(arr)-i-1):
if arr[j]>arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
def insertionsort(arr):
for i in range(1,len(arr)):
j = i
e = arr[i]
while j>0:
if e4.歸併排序
def mergesort(arr):
mergesort(arr, 0, len(arr)-1)
def mergesort(arr, l, r):
if l>=r:
return
mid = int((l+r)/2)
mergesort(arr, l, mid)
mergesort(arr, mid+1, r)
merge(arr, l, mid, r)
def merge(arr, l, mid, r):
aux = arr[l:r+1]
i = l
j = mid+1
for k in range(l,r+1):
if i>mid:
arr[k] = aux[j-l]
j = j+1
elif j>r:
arr[k] = aux[i-l]
i = i+1
elif aux[i-l]>aux[j-l]:
arr[k] = aux[j-l]
j = j+1
else:
arr[k] = aux[i-l]
i = i+1
def mergesortbottomup(arr):
n = len(arr)
s = 1
while s<=n:
i = 0
while i+s < n:
merge(arr, i, i+s-1, min(i+2*s-1,n-1))
i = i+2*s
s = s+s
def quicksort(arr):
quicksort(arr, 0, len(arr)-1)
def quicksort(arr, l, r):
if l>=r:
return
p = partition(arr, l, r)
quicksort(arr, l , p)
quicksort(arr, p+1, r)
def partition(arr, l, r):
v = arr[l]
j = l
for i in range(l+1,r+1):
if arr[i]7.雙路快排
def quicksorttwoways(arr):
quicksorttwoways(arr, 0 ,len(arr)-1)
def quicksorttwoways(arr, l, r):
if l>= r:
return
p = partitiontwoways(arr, l, r)
quicksorttwoways(arr, l, p)
quicksorttwoways(arr, p+1, r)
def partitiontwoways(arr, l, r):
v = arr[l]
i = l+1
j = r
while(true):
while il and arr[j]>v:
j = j -1
if i>j:
break
arr[i],arr[j] = arr[j], arr[i]
i = i+1
j = j-1
arr[l], arr[j] = arr[j], arr[l]
return j
def quicksortthreeways(arr):
quicksortthreeways(arr, 0, len(arr)-1)
def quicksortthreeways(arr, l, r):
if l>=r:
return
v = arr[l]
it = l
gt = r+1
i = l+1
while iv:
gt -= 1
arr[i], arr[gt] = arr[gt], arr[i]
else:
i = i+1
arr[l], arr[it] = arr[it], arr[l]
quicksortthreeways(arr, l, it-1)
quicksortthreeways(arr, gt, r)
def quicksortnr(arr):
l = 0
r = len(arr) - 1
s =
while s:
l = s.pop()
r = s.pop()
if l>=r:
continue
p = partition(arr, l, r)
def heapifysort(arr):
for i in range(int((len(arr)-2)/2),-1,-1):
shiftdown(arr, len(arr)-1, i)
for i in range(len(arr)-1, 0, -1):
arr[0], arr[i] = arr[i] , arr[0]
shiftdown(arr, i-1, 0)
def shiftdown(arr, n, i):
k = i
while 2*k+1<=n:
index = 2*k+1
if 2*k+2 <=n and arr[2*k+2]>arr[2*k+1]:
index = 2*k+2
if arr[k]>= arr[index]:
break
arr[k], arr[index] = arr[index], arr[k]
k = index
python資料結構與演算法篇 排序
1.氣泡排序 英語 bubble sort 它重複地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢 浮 到數列的頂端。氣泡排序演算法的運作如下 首先，...
資料結構與演算法 排序
排序原理 1.比較相鄰的元素。如果前乙個元素比後乙個元素大，就交換這兩個元素的位置。2.對每一對相鄰元素做同樣的工作，從開始第一對元素到結尾的最後一對元素。最終最後位置的元素就是最大 值。氣泡排序的 實現 public static void sortpop int arr 測試 public st...
《資料結構與演算法 排序》
1 快速排序 1.記錄 排序中的結點 2.檔案 一系列結點構成的線性表 3.排序又稱分類 4.排序碼 結點中乙個或者多個字段，其值作為排序運算中的根據。基本思想 每次選擇待排序的記錄序列的第1個記錄，按照排序碼的大小將其插入到已排序的記錄序列的適當位置，直到所有記錄全部排序完畢。最簡單的排序方法。整...