前言
不想再闲的蛋疼去查这些基本的排序算法了
冒泡排序
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
}
}