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

// 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大的一头开始了。