golang实现常用排序算法（一）

冒泡排序

基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。具体如下图所示：

golang代码实现

package main

import "fmt"

func bubbleSort(arr []int) []int {
    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < len(arr)-1; j++ {
            if arr[j+1] < arr[j] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
    return arr
}

func main() {
    arr := []int{3, 6, 4, 2, 11, 10, 5}
    fmt.Println(bubbleSort(arr))
}

上面代码有待优化的地方，例如：当数据的顺序排好之后，冒泡算法仍会执行，直到len(arr)-1次，而后面的比较是没有意义的。
解决方案，设置标志位flag，如果发生了交换，flag设置为true，没有交换，就设置为false。所以当一轮结束后，如果flag仍然为false，表明这一轮没有发生变化，说明数据的顺序已经排号，没有必要进行下一轮。

package main

import "fmt"

func bubbleSort(arr []int) []int {
    var flag bool
    for i := 0; i < len(arr)-1; i++ {
        flag = false
        for j := 0; j < len(arr)-1; j++ {
            if arr[j+1] < arr[j] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag=true
            }
        }
        if !flag {
            break
        }
    }
    return arr
}

func main() {
    arr := []int{3, 6, 4, 2, 11, 10, 5}
    fmt.Println(bubbleSort(arr))
}

选择排序

基本思想：在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换，第二次遍历n-2个数，找到最小的数值与第二个元素交换。。。第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成。具体如下图所示：

golang代码实现

package main

import "fmt"

func main() {
    arr := []int{70, 30, 40, 10, 80, 20, 90, 100, 75, 60, 45}
    fmt.Println(selectSort(arr))
}

func selectSort(arr []int) []int {
    var minIndex int
    for i := 0; i < len(arr)-1; i++ {
        minIndex = i
        for j := i + 1; j < len(arr); j++ {
            if arr[j] < arr[minIndex] {
                minIndex = j
            }
        }
        if minIndex!=i {
            arr[i],arr[minIndex]=arr[minIndex],arr[i]
        }
    }
    return arr
}

插入排序

基本思想：在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排号顺序。具体如下图所示：

golang代码实现

package main

import "fmt"

func insertSort(arr []int) []int {
    for i := 0; i < len(arr)-1; i++ {
        for j := i + 1; j > 0; j-- {
            if arr[j] < arr[j-1] {
                arr[j], arr[j-1] = arr[j-1], arr[j]
            }else {
                break
            }
        }
    }
    return arr
}

func main() {
    arr := []int{3, 6, 4, 2, 11, 10, 5}
    fmt.Println(insertSort(arr))
}

希尔排序

基本思想：在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。具体如下图所示：

golang代码实现

package main

import "fmt"

func shellSort(arr []int) []int {
    increment:=len(arr)
    for {
        increment = increment / 2
        for i := 0; i < increment; i++ {
            for j := i + increment; j < len(arr); j = j + increment {
                for k := j; k > i; k = k - increment {
                    if arr[k] < arr[k-increment] {
                        arr[k], arr[k-increment] = arr[k-increment], arr[k]
                    } else {
                        break
                    }
                }
            }
        }
        if increment == 1 {
            break
        }
    }
    return arr
}

func main() {
    arr := []int{9, 1, 2, 5, 7, 4, 8, 6, 3, 5}
    fmt.Println(shellSort(arr))
}