go语言：排序算法

申明：本文只用做自己的学习记录

1. 冒泡排序

排序算法	平均时间复杂度	空间复杂度	排序方式	稳定性
冒泡排序	O(n2)	O(1)	In-Place	稳定

//冒泡排序(从小到大)
func BubbleSort(nums []int) {
	//冒泡遍历
	for i := 0; i < len(nums); i++ {
		for j := 0; j < len(nums)-1-i; j++ {
			if nums[j] > nums[j+1] {
				nums[j+1], nums[j] = nums[j], nums[j+1]
			}
		}
	}
	return
}

2. 归并排序

排序算法	平均时间复杂度	空间复杂度	排序方式	稳定性
归并排序	O(n log n)	O(n)	Out-Place	稳定

func MergeSort(nums []int) []int {
	//当给定数列长度小于2，则直接返回该数组
	if len(nums) < 2 {
		return nums
	}
	//将该数组分成两半
	left := nums[0 : len(nums)/2]
	right := nums[len(nums)/2:]
	//在各自的一半数组内进行排序
	return Merge(MergeSort(left), MergeSort(right))
}

//归并排序
func Merge(left []int, right []int) []int {
	//申明变量用于存放结果值
	var result []int
	//当左边数列和右边数列都不为空时，比较相同位置元素大小，并放进结果切片中
	for len(left) != 0 && len(right) != 0 {
		if left[0] <= right[0] {
			result = append(result, left[0])
			//删除数组第一个元素
			left = left[1:]
		} else {
			result = append(result, right[0])
			//删除数组第一个元素
			right = right[1:]
		}
	}
	//当左数组不为0，右数组为0时，只对左数组做存储操作
	for len(left) != 0 {
		result = append(result, left[0])
		//删除数组第一个元素
		left = left[1:]
	}
	//当左数组为0，右数组不为0时，只对右数组做存储操作
	for len(right) != 0 {
		result = append(result, right[0])
		//删除数组第一个元素
		right = right[1:]
	}
	return result
}

3. 计数排序

排序算法	平均时间复杂度	空间复杂度	排序方式	稳定性
计数排序	O(n + k)	O(k)	Out-Place	稳定

func CountingSort(results []int, maxValue int) []int {
	//由于最大值不包含0位，故需要增加一位给数字0
	bucket := make([]int, maxValue+1)
	sortedIndex := 0

	//将results切片中的数字装进对应的篮子里
	for i := 0; i < len(results); i++ {
		bucket[results[i]] += 1
	}
	//从小到大遍历篮子中的数值
	for j := 0; j < maxValue+1; j++ {
		//如果bucket[j] > 0说明该位置的数字出现过不止一次
		//如果bucket[j] == 0说明该数字没出现过，不需要排序
		for bucket[j] > 0 {
			//将该位置代表的数字填充进切片中
			results[sortedIndex] = j
			//结果中的索引值加1
			sortedIndex++
			//篮子中代表的数字数量减1
			bucket[j]--
		}
	}
	return results
}

4. 第三方包（sort包）排序

IntNums := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
FloatNums := []float64{4.2, 5.5, 12.7, 11.2, 35.1, 98.9, 30.5, 26.23356, 3.14}
StringNums := []string{"a", "c", "b", "z", "x", "w", "y", "d", "f", "i"}

//sort.Ints()
sort.Ints(IntNums)                              //[0 1 2 3 4 5 6 7 8 9]
sort.Sort(sort.Reverse(sort.IntSlice(IntNums))) //[9 8 7 6 5 4 3 2 1 0]

//sort.Float64s()
sort.Float64s(FloatNums)                              //[3.14 4.2 5.5 11.2 12.7 26.23356 30.5 35.1 98.9]
sort.Sort(sort.Reverse(sort.Float64Slice(FloatNums))) //[98.9 35.1 30.5 26.23356 12.7 11.2 5.5 4.2 3.14]

//sort.Strings()
sort.Strings(StringNums)                              //[a b c d f i w x y z]
sort.Sort(sort.Reverse(sort.StringSlice(StringNums))) //[z y x w i f d c b a]

//sort.Slice()
//排序，传入排序规则
sort.Slice(IntNums, func(i, j int) bool { return IntNums[i] < IntNums[j] }) //[0 1 2 3 4 5 6 7 8 9]