几个排序算法

冒泡排序

func sort(a []int) {
	for i := 0; i < len(a); i++ {
		for j := 0; j < len(a) - i - 1; j++ {
			if a[j] > a[j + 1] {
				a[j], a[j + 1] = a[j + 1], a[j]
			}
		}
	}
}


func main() {
	b := [...]int{7, 85, 5, 9, 0, 12, 3}
	sort(b[:])
	fmt.Println(b)
}

冒泡排序，先将最大(或者最小)的数排到最后，然后最后一位不需要比较，所以在下一次循环的时候，可以少比较一次，因此在第二层循环哪里，循环终止的标志是数组长度减去最外层循环的次数也就是上面的len(a) - i - 1

选择排序

选择排序，即每次选出最大或者最小的数

import "fmt"

func sort1(a []int) {
	for i := 0; i < len(a); i++ {
		for j := i; j < len(a); j++ {
			if a[i] < a[j] {
				a[i], a[j] = a[j], a[i]
			}
		}
	}
}


func main() {
	a := []int {1, 45, 78, 256, 2, 5}
	sort1(a)
	fmt.Println(a)
}

插入排序

插入排序即先以数组的最右边或者最左边的一个数作为一个有序对象，然后再从无序的数里面每次取出一个数跟有序的里面的数进行比较，选择插入的位置，就跟打扑克牌一样，取到牌后按照顺序插入到手中的牌堆里面

import "fmt"

func sort2(a []int) {
	// 从1开始循环，0的位置的数就是有序的
	for i := 1; i < len(a); i++ {
		for j := i; j > 0; j-- {
			if a[j] > a[j - 1] {
				break
			}
			a[j], a[j - 1] = a[j - 1], a[j]
		}
	}
}

func main() {
	a := []int {1, 54, 78, 96}
	sort2(a)
	fmt.Println(a)
}

快速排序

快速排序即先确定一个元素的位置，即在数组中，该元素左边的数全都比它小，右边的数全都比它大，那么这个元素的位置就确定了，然后通过分别对该元素的两边的数组进行递归，重复上述操作即可完成排序操作

import "fmt"

func qsort(a []int, left, right int) {
	// 递归退出条件
	if left >= right {
		return
	}
	val := a[left]   // 选中一个值
	k := left
	// 确定val的位置
	for i := left + 1; i <= right; i++ {
		if a[i] < val {
			// 2 5 7 9 1
			// k       i    将1放在2之前，后面的数依次往后推
			item := a[i]
			for j := i; j > k; j-- {
				a[j] = a[j-1]
			}
			a[k] = item
			k++
		}
	}
	qsort(a, left, k - 1)
	qsort(a, k + 1, right)
}

func main() {
	a := []int {45, 1, 7, 9, 5, 60}
	qsort(a, 0, len(a) - 1)
	fmt.Println(a)
}

优化版

import "fmt"

func qsort(a []int, left, right int) {
	// 递归退出条件
	if left >= right {
		return
	}
	val := a[left]   // 选中一个值
	k := left
	// 确定val的位置
	for i := left + 1; i <= right; i++ {
		if a[i] < val {
			a[k] = a[i]
			a[i] = a[k+1]
			k++
		}
	}
	a[k] = val
	qsort(a, left, k - 1)
	qsort(a, k + 1, right)
}

func main() {
	a := []int {45, 1, 7, 9, 5, 60}
	qsort(a, 0, len(a) - 1)
	fmt.Println(a)
}