Go語言實現 常見排序演算法

2022-08-23 14:54:09 字數 4745 閱讀 3462

氣泡排序:

時間複雜度: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...