Go The Way 之 冒泡排序、快速排序、插入排序、选择排序

排序是最常见的算法

• 冒泡排序

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

	return nums
}

• 选择排序

// 选择排序
func SelectSort(nums []int) []int {
	length := len(nums)
	max, maxindex := 0, 0

	for i := 0; i < length-1; i++ {
		max = nums[i]
		maxindex = i
		for j := i + 1; j < length; j++ {
			if nums[j] > max {
				max = nums[j]
				maxindex = j
			}
		}

		if maxindex != i {
			nums[i], nums[maxindex] = nums[maxindex], nums[i]
		}
	}

	return nums
}

• 插入排序

// 插入排序： 属于内部排序法，是对于预排序的元素以插入的方式找寻该元素的适当位置，以2达到排序的目的
/**
思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中有n-1个元素，排序过程中每次从无序表中取出
第一个元素，把他的排序码依次与有序表元素的排序码进行比较，将她插入到有序表中的适当位置，使之成为新的有序表
*/
func InsertSort(nums []int) []int {
	for i := 1; i < len(nums); i++ {
		insertVal := nums[i]
		insertIndex := i - 1
		for insertIndex >= 0 && nums[insertIndex] <= insertVal {
			nums[insertIndex+1] = nums[insertIndex]
			insertIndex--
		}
		// 插入
		if insertIndex+1 != i {
			nums[insertIndex+1] = insertVal
		}
		fmt.Printf("第%d次插入后的数据为%v\n", i, nums)
	}
	return nums

}

• 快速排序

//快速排序法
/**
快速排序是对冒泡排序的改进，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
然后再按此方法对该两部分数据分别进行快速排序，整个排序的过程可以递归进行，以此达到整个数据编程有序序列
*/

//快速排序
func QuickSort(arr []int, left, right int) []int {

	pivot := 0

	if left < right {

		pivot = partition(arr, left, right)

		QuickSort(arr, left, pivot-1)

		QuickSort(arr, pivot+1, right)

	}
	return arr
}

func partition(arr []int, left, right int) int {

	key := arr[left]

	for left < right {

		for left < right && arr[right] <= key {

			right--

		}

		arr[left] = arr[right]

		for left < right && arr[left] >= key {

			left++

		}

		arr[right] = arr[left]

	}

	arr[left] = key

	return left

}

快速排序步骤详解可见：传送门