go語言十大排序演算法總結

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

選擇排序

選擇排序的基本思想是對待排序的記錄序列進行n-1遍的處理，第i遍處理是將L[i..n]中最小者與L[i]交換位置。這樣，經過i遍處理之後，前i個記錄的位置已經是正確的了。

選擇排序是不穩定的。演算法複雜度是O(n ^2 )。

package mainimport (    "fmt")type SortInterface interface {    sort()}type Sortor struct {    name string}func main() {    arry := []int{6, 1, 3, 5, 8, 4, 2, 0, 9, 7}    learnsort := Sortor{name: "選擇排序--從小到大--不穩定--n*n---"}    learnsort.sort(arry)    fmt.Println(learnsort.name, arry)}func (sorter Sortor) sort(arry []int) {    arrylength := len(arry)    for i := 0; i < arrylength; i++ {        min := i        for j := i + 1; j < arrylength; j++ {            if arry[j] < arry[min] {                min = j            }        }        t := arry[i]        arry[i] = arry[min]        arry[min] = t    }}

輸出為：

/usr/local/go/bin/go build -i [/Users/liuhanlin/GO/src/go_learn]成功: 進程結束代碼 0./Users/liuhanlin/GO/src/go_learn/go_learn  [/Users/liuhanlin/GO/src/go_learn]選擇排序--從小到大--不穩定--n*n--- [0 1 2 3 4 5 6 7 8 9]成功: 進程結束代碼 0.

冒泡排序
冒泡排序方法是最簡單的排序方法。這種方法的基本思想是，將待排序的元素看作是豎著排列的“氣泡”，較小的元素比較輕，從而要往上浮。在冒泡排序演算法中我們要對這個“氣泡”序列處理若干遍。所謂一遍處理，就是自底向上檢查一遍這個序列，並時刻注意兩個相鄰的元素的順序是否正確。如果發現兩個相鄰元素的順序不對，即“輕”的元素在下面，就交換它們的位置。顯然，處理一遍之後，“最輕”的元素就浮到了最高位置；處理二遍之後，“次輕”的元素就浮到了次高位置。在作第二遍處理時，由於最高位置上的元素已是“最輕”元素，所以不必檢查。一般地，第i遍處理時，不必檢查第i高位置以上的元素，因為經過前面i-1遍的處理，它們已正確地排好序。
冒泡排序是穩定的。演算法時間複雜度是O(n ^2)
class EbullitionSorter
{
public void Sort(int[] arr)
{
int i, j, temp;
bool done = false;
j = 1;
while ((j < arr.Length) && (!done))//判斷長度
{
done = true;
for (i = 0; i < arr.Length - j; i++)
{
if (arr[i] > arr[i + 1])
{
done = false;
temp = arr[i];
arr[i] = arr[i + 1];//交換資料
arr[i + 1] = temp;
}
}
j++;
}
}
}

快速排序
快速排序是對冒泡排序的一種本質改進。它的基本思想是通過一趟掃描後，使得排序序列的長度能大幅度地減少。在冒泡排序中，一次掃描只能確保最大數值的數移到正確位置，而待排序序列的長度可能只減少1。快速排序通過一趟掃描，就能確保某個數（以它為基準點吧）的左邊各數都比它小，右邊各數都比它大。然後又用同樣的方法處理它左右兩邊的數，直到基準點的左右只有一個元素為止。

快速排序是不穩定的。最理想情況演算法時間複雜度O(nlog2n)，最壞O(n ^2)。
class QuickSorter
{
private void swap(ref int l, ref int r)
{
int temp;
temp = l;
l = r;
r = temp;
}
public void Sort(int[] list, int low, int high)
{
int pivot;//儲存分支點
int l, r;
int mid;
if (high <= low)
return;
else if (high == low + 1)
{
if (list[low] > list[high])
swap(ref list[low], ref list[high]);
return;
}
mid = (low + high) >> 1;
pivot = list[mid];
swap(ref list[low], ref list[mid]);
l = low + 1;
r = high;
do
{
while (l <= r && list[l] < pivot)
l++;
while (list[r] >= pivot)
r–;
if (l < r)
swap(ref list[l], ref list[r]);
} while (l < r);
list[low] = list[r];
list[r] = pivot;
if (low + 1 < r)
Sort(list, low, r - 1);
if (r + 1 < high)
Sort(list, r + 1, high);
}
}

插入排序
插入排序的基本思想是，經過i-1遍處理後,L[1..i-1]己排好序。第i遍處理僅將L[i]插入L[1..i-1]的適當位置，使得L[1..i]又是排好序的序列。要達到這個目的，我們可以用順序比較的方法。首先比較L[i]和L[i-1]，如果L[i-1]≤ L[i]，則L[1..i]已排好序，第i遍處理就結束了；否則交換L[i]與L[i-1]的位置，繼續比較L[i-1]和L[i-2]，直到找到某一個位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]時為止。圖1示範了對4個元素進行插入排序的過程，共需要(a),(b),(c)三次插入。
直接插入排序是穩定的。演算法時間複雜度是O(n ^2) 。

public class InsertionSorter
{
public void Sort(int[] arr)
{
for (int i = 1; i < arr.Length; i++)
{
int t = arr[i];
int j = i;
while ((j > 0) && (arr[j - 1] > t))
{
arr[j] = arr[j - 1];//交換順序
–j;
}
arr[j] = t;
}
}
}

希爾排序
希爾排序基本思想： 先取一個小於n的整數d1作為第一個增量，把檔案的全部記錄分成d1個組。所有距離為dl的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然後，取第二個增量d2