golang實現經常使用排序算法

1.冒泡排序，算法複雜度O(n^2)

package main

import (

    "fmt"

)

func main() {

    var arr = []int{10, 17, 19, 18, 77, 55}

    for i := 0; i < len(arr)-1; i++ {

        for j := i + 1; j < len(arr); j++ {

            if arr[i] > arr[j] {

                arr[i], arr[j] = arr[j], arr[i]

            }

        }

    }

    fmt.Println(arr)

}

2.快速排序

它的基本思想是：經過一趟排序將數據一分爲二，其中一部分的全部數據都比另一部分的全部數據都要小，而後對兩部分遞歸，直至完成。時間複雜度介於O(nlogn)和O(n^2)

一趟快速排序的算法是：

1）設置兩個變量i、j，排序開始的時候：i=0，j=N-1；

2）以第一個數組元素做爲關鍵數據，賦值給key，即key=A[0]；

3）從j開始向前搜索，即由後開始向前搜索(j--)，找到第一個小於key的值A[j]，將A[j]賦給A[i]；

4）從i開始向後搜索，即由前開始向後搜索(i++)，找到第一個大於key的A[i]，將A[i]賦給A[j]；

5）重複第三、4步，直到i=j；

package main

import (

    "fmt"

)

func main() {

    quictSort()

}

func quictSort() {

    var arr = []int{50, 66, 44, 99, 77, 24}

    recurtion(arr, 0, len(arr)-1)

    fmt.Println(arr)

}

func recurtion(arr []int, left int, right int) {

    if left < right {

        var i, j = left, right

        var key = arr[i]

        for i < j {

            for i < j && arr[j] >= key {

                j--

            }

            arr[i] = arr[j]

            for i < j && arr[i] <= key {

                i++

            }

            arr[j] = arr[i]

        }

        arr[i] = key

        recurtion(arr, left, i-1)

        recurtion(arr, i+1, right)

    }

}

3.插入排序

時間複雜度O(n^2)，不適合大量數據處理

從第二個值開始遍歷，與前面的有序列比較，若比前面值小則交換

package main

import (

    "fmt"

)

func main() {

    insertSort()

}

func insertSort() {

    var arr = []int{50, 66, 44, 99, 77, 24}

    for i := 1; i < len(arr); i++ {

        for j := 0; j < i; j++ {

            if arr[i] < arr[j] {

                arr[i], arr[j] = arr[j], arr[i]

            }

        }

    }

    fmt.Println(arr)

}

4.歸併排序 算法複雜度O(nlogn)

是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分爲若干個有序的子序列，再把有序的子序列合併爲總體有序序列。

package main

import "fmt"

func main() {
    arr := []int{39, 19, 28, 6, 44, 77, 15}
    mergeSort(arr, 0, len(arr)-1)
    fmt.Println(arr)
}
func merge(arr []int, first, mid, last int) {
    buf := make([]int, last+1)
    i := first
    j := mid + 1
    var num int = first
    for i <= mid && j <= last {
        if arr[i] < arr[j] {
            buf[num] = arr[i]
            i++
        } else {
            buf[num] = arr[j]
            j++
        }
        num++
    }
    for i <= mid {
        buf[num] = arr[i]
        num++
        i++
    }
    for j <= last {
        buf[num] = arr[j]
        num++
        j++
    }
    copy(arr[first:], buf[first:])
}
func mergeSort(arr []int, first, last int) {
    if first < last {
        mid := (first + last) / 2
        mergeSort(arr, first, mid)
        mergeSort(arr, mid+1, last)
        merge(arr, first, mid, last)
    }
}