氣泡排序：
時間複雜度：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...