go语言实现六种排序

一、快速排序

func quickSort(a []int, start, end int) {
	if end <= start {
		return
	}
	nStart := start
	nEnd := end
	//需要从后往前
	for nStart < nEnd {
		for nStart < nEnd && a[nEnd] >= a[start] {
			nEnd--
		}
		for nStart < nEnd && a[nStart] <= a[start] {
			nStart++
		}
		if nStart < nEnd {
			a[nStart], a[nEnd] = a[nEnd], a[nStart]
		}
	}
	a[start], a[nStart] = a[nStart], a[start]
	quickSort(a, start, nStart-1)
	quickSort(a, nStart+1, end)
}

二、归并排序

func mergeSort(a []int, start, end int) {
	if end-start <= 1 {
		return
	}
	mid := (start + end) / 2
	mergeSort(a, start, mid)
	mergeSort(a, mid, end)
	left := make([]int, mid-start)
	right := make([]int, end-mid)
	copy(left, a[start:mid])
	copy(right, a[mid:end])
	i := 0
	j := 0
	for k := start; k < end; k++ {
		switch {
		case i >= len(left):
			a[k] = right[j]
			j++
		case j >= len(right):
			a[k] = left[i]
			i++
		case left[i] > right[j]:
			a[k] = right[j]
			j++
		case left[i] <= right[j]:
			a[k] = left[i]
			i++
		}
	}
}

三、冒泡排序

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

四、插入排序

func insertSort(s []int) {
	length := len(s)
	for i := 0; i < length; i++ {
		for j := i; j > 0; j-- {
			if s[j] < s[j-1] {
				s[j], s[j-1] = s[j-1], s[j]
			} else {
				break
			}
		}
	}
}

五、选择排序

func chooseSort(s []int) {
	length := len(s)
	for i := 0; i < length; i++ {
		min := i
		for j := length - 1; j >= i; j-- {
			if s[j] < s[min] {
				min = j
			}
		}
		s[min], s[i] = s[i], s[min]
	}
}

六、堆排序

1、引用go的库来实现

import (
	"container/heap"
	"fmt"
)

//堆排序调库初始化
type NewHeap []int

func (h NewHeap) Len() int {
	return len(h)
}

func (h NewHeap) Less(x, y int) bool {
	return h[x] < h[y]
}

func (h NewHeap) Swap(x, y int) {
	h[x], h[y] = h[y], h[x]
}

func (h *NewHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *NewHeap) Pop() interface{} {
	n := len(*h)
	x := (*h)[n-1]
	*h = append((*h)[:n-1])
	return x
}

2、自己实现

func sort(num []int) {
	length := len(num) - 1
	for root := length / 2; root >= 0; root-- {
		buildHeap(num, length, root)
	}
	for end := length; end >= 0; end-- {
		if num[0] > num[end] {
			num[0], num[end] = num[end], num[0]
			buildHeap(num, end-1, 0)
		}
	}
}

func buildHeap(num []int, end, root int) {
	child := root*2 + 1
	for {
		if child > end {
			break
		}
		if child+1 <= end && num[child] < num[child+1] {
			child += 1
		}
		if num[root] < num[child] {
			num[root], num[child] = num[child], num[root]
			root = child
			child = root*2 + 1
		} else {
			break
		}
	}
}