算法：数组排序（1）

排序算法

1. 冒泡排序法
   循环遍历数组，依次比较相邻的两个数据，根据大小关系决定是否进行互换。每一次遍历会把当前最大的数移到最后面，经过n次遍历即可完成排序
2. 插入排序法
   把数组分为有序区间和无序区间，每次从无序区间取出一个数，放到有序区间正确的位置。重复此过程，直至无序区间为空
3. 选择排序法
   把数组分为已排序区间和未排序区间，每次取出未排序区间最小值，放入已排序区间末尾。重复此过程，直至未排序区间为空

以下是三种算法的golang实现，仅供参考。

package main

import "fmt"

func main() {
	var lists = [][]int{
		[]int{2, 4, 1, 7, 5, 9},
		[]int{9, 6, 8, 2, 1, 6, 2, 0, 111},
		[]int{1},
		[]int{2, 4},
		nil,
	}
	for _, list := range lists {
		l1 := bubbleSort(list)
		fmt.Println(l1)
		l2 := insertSort(list)
		fmt.Println(l2)
		l3 := selectSort(list)
		fmt.Println(l3)
	}
}

// bubbleSort  冒泡排序
func bubbleSort(l []int) []int {
	length := len(l)
	if length < 2 {
		return l
	}
	for i := length - 1; i > 0; i-- {
		for j := 0; j < i; j++ {
			if l[j] > l[j+1] {
				l[j], l[j+1] = l[j+1], l[j]
			}
		}
	}
	return l
}

// insertSort 插入排序
func insertSort(l []int) []int {
	length := len(l)
	if length < 2 {
		return l
	}
	for i := 1; i < length-1; i++ {
		for j := i - 1; j >= 0; j-- {
			if l[j] > l[j+1] {
				l[j], l[j+1] = l[j+1], l[j]
			}
		}
	}
	return l
}

// selectSort 选择排序
func selectSort(l []int) []int {
	length := len(l)
	if length < 2 {
		return l
	}
	for i := 0; i < length-1; i++ {
		for j := i + 1; j < length; j++ {
			if l[i] > l[j] {
				l[i], l[j] = l[i], l[j]
			}
		}
	}
	return l
}

执行输出如下

[1 2 4 5 7 9]
[1 2 4 5 7 9]
[1 2 4 5 7 9]
[0 1 2 2 6 6 8 9 111]
[0 1 2 2 6 6 8 9 111]
[0 1 2 2 6 6 8 9 111]
[1]
[1]
[1]
[2 4]
[2 4]
[2 4]
[]
[]
[]