【无标题】

1. 冒泡排序

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

2. 快速排序I

// 快排
func sortNum(list []int, scope ...int) {
	if len(scope) == 0 {
		scope = []int{0, len(list) - 1}
	}

	// 数组元素个数小于2 ，左指针不小于右指针 退出
	if len(list) < 2 || scope[0] > scope[1] {
		return
	}

	low, high := scope[0], scope[1]

	// 随机选择基准元素
	index := rand.Intn(high-low+1) + low
	povit := list[index]
	list[index] = list[low]
	for low < high {
		// 右指针
		for low < high && list[high] > povit {
			high--
		}

		// 比基准值小移动到左边左指针+1
		if low < high {
			list[low] = list[high]
			low++
		}

		// 左指针
		for low < high && list[low] <= povit {
			low++
		}

		// 比基准值大移动到右部右指针-1
		if low < high {
			list[high] = list[low]
			high--
		}
	}
	list[low] = povit
	sortNum(list, scope[0], low-1)
	sortNum(list, high+1, scope[1])
}

3.快速排序II

func sort2(arr []int, start int, end int) {
	if start >= end {
		return
	}

	var left, right, tem int
	left, right = start, end
	tem = arr[left]

	for left < right {

		for arr[right] >= tem && left < right { // 找到右边小于基准的元素
			right--
		}

		for arr[left] <= tem && left < right { // 找到一个左边大于基准元素的元素
			left++
		}

		if left < right { // left < right 说明上面的查找成功 进行元素交换
			arr[left], arr[right] = arr[right], arr[left]
		}
	}
	// 当left = right 的时候，此时 arr[left] 元素一定小于 tem基准元素的值 直接交换就行
	arr[left], arr[start] = tem, arr[left]

	sort(arr, start, left-1)
	sort(arr, left+1, end)
}

4. 插入排序

// 插入排序
func sortNum(nums []int) {
	for i := 1; i < len(nums); i++ {
		for j := i; j != 0 && nums[j] < nums[j-1]; j-- {
			nums[j], nums[j-1] = nums[j-1], nums[j]
		}
	}
}

5.选择排序

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