氣泡排序:
時間複雜度:o(n^2)
穩定性:穩定
//氣泡排序
//相鄰兩位交換,12交換,23交換,34交換,把最大的數放到最右邊
//利用flag標記可以避免無效迴圈
func
bubblesort
(arr [
]int)}
//true表示序列已經有序,直接退出,不用繼續迴圈
//false表示本次迴圈發生了交換,需要繼續判斷下個迴圈
if flag
}}
簡單選擇排序:
時間複雜度:o(n^2)
穩定性:不穩定
//簡單選擇排序
//迴圈一遍,把最小的放最左邊;迴圈剩下的序列
//迴圈時只取值比較,一遍迴圈完發生交換
func
selectsort
(arr [
]int)}
//迴圈完一遍,最小值發生過變化
if min != i
}}
直接插入排序:
時間複雜度:o(n^2)
穩定性:穩定
//直接插入排序
//取首元素作為有序佇列,把第二位插入到有序佇列中,把第三位插入到前兩位組成的有序佇列中
//新的一位插入有序佇列時,跟他的前一位比較,即有序佇列的最右邊,依次向前遍歷
func
insertsort
(arr [
]int
)//因為發生了j--
arr[j+1]
= temp
}}}
希爾排序:
時間複雜度:o(n^1.5)
穩定性:不穩定
//希爾排序
//按間隔分組,每組進行插入排序
//長度為10,間隔為10/2=5,按(0,5)(1,6)(2,7)(3,8)(4,9)分組
//間隔減小為5/2=2,按(0,2,4,6,8)(1,3,5,7,9)分組
//組內插入排序時,各組之間交替比較,以間隔為2舉例:先比較0和2,再比較1和3,再比較4,再比較5,依次遍歷
//直到間隔為1,按(0,1...9)分組
func
shellssort
(arr [
]int
) arr[j+gap]
= temp
}}}}
歸併排序:
時間複雜度:o(nlogn)
穩定性:穩定
//歸併排序
//將兩個有序序列合併成乙個有序序列
//取中間值分左右遞迴處理
func
mergesort
(r [
]int)[
]int
//左右分別處理
num := length /
2 left :=
mergesort
(r[:num]
) right :=
mergesort
(r[num:])
//左右兩邊都為有序,進行合併
return
merge
(left, right)
}func
merge
(left, right [
]int
)(result [
]int
)else
}//left和right均為有序,直接將剩餘部分加進序列
//如果上面是left遍歷完,left[l:]為,right還有剩餘值
//如果上面是right遍歷完,right[r:]為, left還有剩餘值
result =
(result, left[l:
]...
) result =
(result, right[r:
]...
)return
}
快速排序:
時間複雜度:o(nlogn)
穩定性:不穩定
//快速排序
//取首位元素為臨界值,一遍迴圈,臨界值左邊為小數,右邊為大數
//遞迴臨界值左邊和右邊
func
quicksort
(arr [
]int
)quick
(arr,
0, length-1)
}func
quick
(arr [
]int
, start, end int
) i, j := start, end
//取首位元素為分界值
temp := arr[i]
for i < j
//直到遇見第乙個小的,跳出上面迴圈
if i < j
//從左往右找,小的不處理,i++
for i < j && arr[i]
<= temp
//直到遇見第乙個大的,跳出上面迴圈
if i < j
}//把temp給到i位置
arr[i]
= temp
//遞迴i的左邊,0到i-1
quick
(arr, start, i-1)
//遞迴i的右邊,i+1到right
quick
(arr, i+
1, end)
}
堆排序:
時間複雜度:o(nlogn)
穩定性:不穩定
//堆排序
//公升序使用大頂堆,降序使用小頂堆,以大頂堆為例
//頂堆是上下比較大小,父結點與其孩子比較,同一父結點的左右大小無限制,二叉搜尋樹是左右比較大小,不要搞混
//先調整序列為大頂堆(序列預設是一棵二叉樹,把該二叉樹調整為大頂堆)
//處理大頂堆:首尾交換,末位最大,去掉末位,調整剩下序列為大頂堆,迴圈處理
func
heapsort
(arr [
]int)[
]int
//處理大頂堆
//大頂堆左右無序,上下有序
for i := length -
1; i >
0; i--
return arr
}//調整二叉樹為大頂堆
func
adjustheap
(arr [
]int
, i, length int
)//存在右孩子且右孩子更大,最大指向right
if right < length && arr[right]
> arr[max]
//最大發生過改變,交換
if max != i
}
基數排序:
時間複雜度:o(d(n+r))
穩定性:穩定
//基數排序
//分配式排序,桶子法,非負數,共0-9,10個桶子
//首次迴圈根據元素個位數,將元素分配至對應桶子裡,0進0號桶,9進9號桶
//按桶子排序,再次迴圈,根據元素十位數再次分配
func
radixsort
(arr [
]int
)//元素的最大位數
d :=
maxbit
(arr)
//用mod和dev求對應位數上的數值
mod, dev :=10,
1//迴圈位數
for i :=
0; i < d; i++
//遍歷序列
for j :=
0; j < length; j++
//為arr排序時的下標
k :=
0//排序arr
for m :=
0; m <
10; m++
}//為下一位做準備
mod *=
10 dev *=10}
}//基數排序
//分配式排序,桶子法,存在負數,共0-19,20個桶子
//首次迴圈根據元素個位數,將元素分配至對應桶子裡,-9進1號桶,-1進9號桶,0進10號桶,1進11號桶,19進19號桶
//按桶子排序,再次迴圈,根據元素十位數再次分配
func
radixsort
(arr [
]int
)//元素的最大位數
d :=
maxbit
(arr)
//用mod和dev求對應位數上的數值
mod, dev :=10,
1//迴圈位數
for i :=
0; i < d; i++
//遍歷序列
for j :=
0; j < length; j++
//為arr排序時的下標
k :=
0//排序arr
for m :=
0; m <
20; m++
}//為下一位做準備
mod *=
10 dev *=10}
}//元素的最大位數
func
maxbit
(arr [
]int
)int
}return d
}
Go語言實現 常見排序演算法
氣泡排序 時間複雜度 o n 2 穩定性 穩定 氣泡排序 相鄰兩位交換,12交換,23交換,34交換,把最大的數放到最右邊 利用flag標記可以避免無效迴圈 func bubblesort arr int true表示序列已經有序,直接退出,不用繼續迴圈 false表示本次迴圈發生了交換,需要繼續判...
演算法 選擇排序(go語言實現)
選擇排序與氣泡排序的時間複雜度相同。因為一直在選擇最小的數字,所以叫選擇排序 理論部分 1,將設陣列0號位為陣列最小值,將其定義為minnum 此時 minnum 5 2,遍歷陣列,將每一項和 minnum 對比,如果小於minnum,則將其與第一項調換位置 並重新賦值 minnum 變換為此時 m...
排序演算法的GO語言實現
func bubblesort arr int,arrlength int if flag 把數字插入到合適的位置 package algo import testing 第乙個數字是有序的,從後面的數字取乙個出來,放在有序範圍內 func insertionsort arr int,arrleng...