在学习golang语言，文档看的实在是乏味，就想着把常用的算法做个实现，边写变学习，想来效果还是不错的！

1. 堆排序

package main
    
import "fmt"

func buildHeap(array []int, length int) {
        var i, j int;
        for i = 1; i < length; i = i + 1 {
            for j = i; j > 0 && array[j] > array[(j-1)/2]; j = (j - 1)/2  {
                array[j], array[(j-1)/2] = array[(j-1)/2], array[j]  
            }
        }
    }

func heapSort(array []int, length int) {
        array[0], array[length - 1] = array[length - 1], array[0]
        if length <= 2 {
            return
        }
        i, j:= 0, 0
        for  {
            j = 2 * i + 1
            if j + 1 < length - 1 {
                if array[j] < array[j + 1] {
                    j = j + 1
                }
            } else if j >= length -1 {
                break
            }   
            array[i], array[j] = array[j], array[i]
            i = j
        }
        heapSort(array, length - 1)
    }
func main() {
        primes := [6]int{3, 11, 5, 2, 13, 7}
        fmt.Println("orginal", primes)
        buildHeap(primes[:], len(primes))
        fmt.Println("Max heap", primes)
        heapSort(primes[:], len(primes))
        fmt.Println("after sorting", primes)
}

    /**
        out:
            orginal [3 11 5 2 13 7]
            Max heap [13 11 7 2 3 5]
            after sorting [2 3 5 7 11 13]
    
    **/

2.冒泡排序

package main

import "fmt"

func BubbleSort(vector []int) {
    fmt.Println("BubbleSort")
    fmt.Println(vector)
    for i := 0; i < len(vector); i++ {
        tag := true // 为了剪枝
        // 每一趟将最大的数冒泡
        for j := 0; j < len(vector)-i-1; j++ {
            if vector[j] > vector[j+1] { /*vector[j] < vector[j+1]*/
                temp := vector[j]
                vector[j] = vector[j+1]
                vector[j+1] = temp
                tag = false
            }
        }
        if tag {
            break //0~len(vector)-i没有发生交换说明已经有序
        }
        fmt.Println(vector)
    }
}

func main() {
        primes := [6]int{3, 11, 5, 2, 13, 7}
        fmt.Println("orginal", primes)
        BubbleSort(primes[:])
        fmt.Println("after sorting", primes)
}
  /**
    out:
        orginal [3 11 5 2 13 7]
        BubbleSort
        [3 11 5 2 13 7]
        [3 5 2 11 7 13]
        [3 2 5 7 11 13]
        [2 3 5 7 11 13]
        after sorting [2 3 5 7 11 13]

  **/
    

3. 插入排序

package main

import "fmt"

func InsertSort(vector []int) {
    fmt.Println("InsertSort")
    fmt.Println(vector)
    for i := 1; i < len(vector); i++ {
        // 每一趟不满足条件就选择i为哨兵保存，将哨兵插入0~i-1有序序列（0~i-1始终是有序的）
        if vector[i] < vector[i-1] { /*vector[i] > vector[i-1]*/
            temp := vector[i]
            //后移直到找到哨兵合适的位置
            j := i - 1
            for ; j >= 0 && vector[j] > temp; j-- { /*vector[j] < temp*/
                vector[j+1] = vector[j]
            }
            //插入位置前后都是有序的，最后也是有序的
            vector[j+1] = temp
        }
        fmt.Println(vector)
    }
}
func main() {
    primes := [6]int{3, 11, 5, 2, 13, 7}
    fmt.Println("orginal", primes)
    InsertSort(primes[:])
    fmt.Println("after sorting", primes)
}

/**
    out:
        orginal [3 11 5 2 13 7]
        InsertSort
        [3 11 5 2 13 7]
        [3 11 5 2 13 7]
        [3 5 11 2 13 7]
        [2 3 5 11 13 7]
        [2 3 5 11 13 7]
        [2 3 5 7 11 13]
        after sorting [2 3 5 7 11 13]
**/

    

4. 选择排序

package main

import "fmt"

func SelectSort(vector []int) {
    fmt.Println("SelectSort")
    fmt.Println(vector)
    for i := 0; i < len(vector); i++ {
        // 选择最小的元素
        k := i
        for j := i + 1; j < len(vector); j++ {
            if vector[k] > vector[j] {
                k = j
            }
        }
        // 交换
        if k != i {
            temp := vector[i]
            vector[i] = vector[k]
            vector[k] = temp
        }
        fmt.Println(vector)
    }
}
func main() {
    primes := [6]int{3, 11, 5, 2, 13, 7}
    fmt.Println("orginal", primes)
    SelectSort(primes[:])
    fmt.Println("after sorting", primes)
}

/**
    out:
        orginal [3 11 5 2 13 7]
        SelectSort
        [3 11 5 2 13 7]
        [2 11 5 3 13 7]
        [2 3 5 11 13 7]
        [2 3 5 11 13 7]
        [2 3 5 7 13 11]
        [2 3 5 7 11 13]
        [2 3 5 7 11 13]
        after sorting [2 3 5 7 11 13]
**/

5. 二元选择排序

package main

import "fmt"

func BinarySelectSort(vector []int) {
    fmt.Println("SelectSort")
    fmt.Println(vector)
    n := len(vector)
    for i := 0; i < n/2; i++ {
        // 选择最小的元素和最大元素
        k := i
        t := n - i - 1
        for j := i + 1; j <= n-i-1; j++ {
            if vector[k] > vector[j] {
                k = j
            }
            if vector[t] < vector[j] {
                t = j
            }
        }
        // 交换
        if k != i {
            temp := vector[i]
            vector[i] = vector[k]
            vector[k] = temp
        }
        if t != n-i-1 {
            temp := vector[n-i-1]
            vector[n-i-1] = vector[t]
            vector[t] = temp
        }
        fmt.Println(vector)
    }
}
func main() {
    primes := [6]int{3, 11, 5, 2, 13, 7}
    fmt.Println("orginal", primes)
    BinarySelectSort(primes[:])
    fmt.Println("after sorting", primes)
}

/**
    out:
        orginal [3 11 5 2 13 7]
        SelectSort
        [3 11 5 2 13 7]
        [2 11 5 3 7 13]
        [2 3 5 11 7 13]
        [2 3 5 11 7 13]
        after sorting [2 3 5 11 7 13]
**/