Golang 冒泡、选择、插入、希尔、归并、快速、堆排序集锦

前言

不想再闲的蛋疼去查这些基本的排序算法了

冒泡排序

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

选择排序

func SelectSort(data []int) {
	size := len(data)
	for i := 0; i < size; i++ {
		min := i
		for j := i + 1; j < size; j++ {
			if data[j] < data[min] {
				min = j
			}
		}
		if min != i {
			data[i], data[min] = data[min], data[i]
		}
	}
}

插入排序

// k表示步长，步长为1的时候就是插入排序
func InsertSort(data []int, k int) {
	size := len(data)
	for i := k; i < size; i++ {
		for j := i; j >= 0 && data[j] < data[j-1]; j-- {
			data[j], data[j-1] = data[j-1], data[j]
		}
	}
}

希尔排序

// 以长度除2为初始步长，直到步长为1
func ShellSort(data []int) {
	for step := len(data) / 2; step > 0; step-- {
		InsertSort(data, step)
	}
}

归并排序（需要优化）

func mergeSort(data []int) []int {
	if len(data) < 2 {
		return data
	}
	middle := len(data) / 2
	left := mergeSort(data[:middle])
	right := mergeSort(data[middle:])
	return merge(left, right)
}

func merge(left, right []int) []int {
	res := make([]int, 0, len(left)+len(right))
	for len(left) > 0 && len(right) > 0 {
		if left[0] <= right[0] {
			res = append(res, left[0])
			left = left[1:]
		} else {
			res = append(res, right[0])
			right = right[1:]
		}
	}
	if len(left) > 0 {
		res = append(res, left...)
	}
	if len(right) > 0 {
		res = append(res, right...)
	}
	return res
}

快速排序（来源：官方Sort包）

func quickSort(data []int) {
	qs(data, 0, len(data)-1)
}

func qs(data []int, lo, hi int) {
	if lo >= hi {
		return
	}

	middle := int(uint(lo+hi) >> 1)
	medianOfThree(data, lo, middle, hi)
	i, j, pivot := lo, hi, data[lo]
	
	for i < j {
		for ; i < j && data[j] > pivot; j-- {

		}
		if i < j {
			data[i], data[j] = data[j], data[i]
			i++
		}
		for ; i < j && data[i] < pivot; i++ {

		}
		if i < j {
			data[i], data[j] = data[j], data[i]
			j--
		}
	}
	data[j] = pivot
	qs(data, lo, j-1)
	qs(data, j+1, hi)
}

func medianOfThree(data []int, a, b, c int) {
	if data[a] < data[b] {
		data[a], data[b] = data[b], data[a]
	}
	if data[c] < data[a] {
		data[c], data[a] = data[a], data[c]
		if data[a] < data[b] {
			data[a], data[b] = data[b], data[a]
		}
	}
}

堆排序（来源：官方Sort包）

func heapSort(data []int) {
	hi := len(data) - 1
	for i := (hi - 1) / 2; i >= 0; i-- {
		heapify(data, i, hi)
	}
	for i := hi - 1; i >= 0; i-- {
		data[0], data[i+1] = data[i+1], data[0]
		heapify(data, 0, i)
	}
}

func heapify(data []int, root, end int) {
	for {
		child := 2*root + 1
		if child > end {
			return
		}
		if  child < end && data[child] < data[child+1]  {
			child++
		}
		if data[root] >= data[child] {
			return
		}
		data[root], data[child] = data[child], data[root]
		root = child
	}
}