插入排序，归并排序和冒泡排序（怎么以前觉得那么难呢？）

// mergesort project main.go
package main

import (
    "fmt"
)

func main() {
    array := []int{25, 18, 23, 54, 27, 95, 12, 36, 5, 49, 32}
    arrays := array[:]
    MergeSort(arrays, 0, len(arrays)-1)
    display(arrays)
}

func MergeSort(arrays []int, low, high int) {
    if low < high {
        mid := (low + high) / 2
        MergeSort(arrays, low, mid)
        MergeSort(arrays, mid+1, high)
        merge(arrays, low, mid+1, high)
    }

}
func merge(arrays []int, low, mid, high int) {
    midrec := mid
    lowrec := low
    array := make([]int, high-low+1)
    count := 0
    for low < midrec && mid <= high {
        if arrays[low] <= arrays[mid] {
            array[count] = arrays[low]
            low++
        } else {
            array[count] = arrays[mid]
            mid++
        }
        count++
    }
    for low < midrec {
        array[count] = arrays[low]
        low++
        count++
    }
    for mid <= high {
        array[count] = arrays[mid]
        mid++
        count++
    }
    for i := 0; i < (high - lowrec + 1); i++ {
        arrays[lowrec+i] = array[i]
    }
}

func display(arrays []int) {
    for i := 0; i < len(arrays); i++ {
        fmt.Print(arrays[i], "\t")
    }
    fmt.Println()
}

归并排序，跟名字一样，最主要的步骤就是归并。把两个已经有序的序列合并为一个序列。这里原来比较迷惑的就是确定low,mid,high。在合并时候，老是出错，忘记了一个问题，指针是会移动的，如果后面需要用到，要提前将结果保存下来。找了好久的问题，实在是不应该啊。

插入排序跟平时玩牌时候大家放排的习惯很一样，都是将一个个元素插入到一个有序序列中，通过移动的方式实现。

// insertsort project main.go
package main

import (
    "fmt"
)

func main() {
    array := []int{25, 36, 54, 23, 15, 36, 87, 1, 69, 48, 62, 47}
    arrays := array[:]
    fmt.Println("before sort:")
    display(arrays)
    InsertSort(arrays)
    fmt.Println("after sort:")
    display(arrays)
}

func InsertSort(arrays []int) {
    size := len(arrays)
    for i := 1; i < size; i++ {
        if arrays[i] < arrays[i-1] {
            temp := arrays[i]
            var j int
            for j = i - 1; j >= 0 && arrays[j] > temp; j-- {
                arrays[j+1] = arrays[j]
            }
            if j == -1 {
                arrays[0] = temp
            } else {
                arrays[j+1] = temp
            }
        }
        display(arrays)
    }
}
func display(arrays []int) {
    for i := 0; i < len(arrays); i++ {
        fmt.Print(arrays[i], "\t")
    }
    fmt.Println()
}

// bubblesort project main.go
package main

import (
    "fmt"
)

func main() {
    array := []int{25, 18, 23, 54, 27, 95, 12, 36, 5, 49, 32}
    arrays := array[:]
    BubbleSort(arrays)
    display(arrays)
}
func BubbleSort(arrays []int) {
    size := len(arrays)
    for i := 1; i <= size; i++ {
        for j := size - 1; j >= i; j-- {
            if arrays[j] < arrays[j-1] {
                swap(&arrays[j], &arrays[j-1])
            }
        }
    }
}
func swap(numa, numb *int) {
    temp := *numa
    *numa = *numb
    *numb = temp
}

func display(arrays []int) {
    for i := 0; i < len(arrays); i++ {
        fmt.Print(arrays[i], "\t")
    }
    fmt.Println()
}

上面的冒泡算法是可以优化的，我没有写。我一直在找一个正确的冒泡排序写法，所谓正确就是对得起冒泡这个名字，可是现在也没有找到。我理解的冒泡就是较小的气泡向上浮动，所以就从size大的一头开始了。