go语言实现堆排序

大顶堆：所有父节点的值大于大于子节点的值
小顶堆：所有父节点的值小于大于子节点的值

因此，我们可以从堆顶取出元素, 与数组最后一位交换，然后重新维护堆的性质，再取堆顶元素和最后第二位交换…不断交换，直至使数组有序。

通过观察我们可以发现，节点为下标为i的元素，有以下性质：

父节点下标为：(i-1) / 2                        ps: 为整除
左孩子节点下标为：2 * i + 1
右孩子节点下标为：2 * i + 2

1.堆化

当我们要给下标为i的节点，调整为满足堆的性质可以这样定义一个方法

/**
* arr 数组
* n 数组长度
* i 下标为i
*/
func heapify(arr []int, n int, i int) {
    // 先定义最大值为下标为i的元素
	largest := i
	lson := 2 * i + 1 // 左孩子下标
	rson := 2 * i + 2 // 右孩子下标
	if lson < n && arr[largest] < arr[lson] {
		largest = lson
	}
	if rson < n && arr[largest] < arr[rson] {
		largest = rson
	}
	// 最大值不是i, 则交换值。交换完之后，子节点同样要满足堆性质，于是递归该下标
	if largest != i {
		arr[largest], arr[i] = arr[i], arr[largest]
		heapify(arr, n, largest)
	}
}

2. 建堆

注意： 我们需要从最后一个父节点开始调整堆
长度为n的数组，最后一个元素下标为n-1, 所以它的父级下标为 (n-1-1) / 2 = n/2 - 1

func buildHeap(arr []int) {
    n := len(arr)
	for i:=n/2-1; i>=0; i--{
		heapify(arr, n, i)
	}
}

3. 堆排序

func HeapSort(arr []int) {
 	n := len(arr)
	buildHeap(arr)
	for i := n-1; i>0;i--{
		arr[0], arr[i] = arr[i], arr[0]
		heapify(arr, i, 0)
	}
}

package main

import "fmt"

func heapify(arr []int, n int, i int) {
	// 先定义最大值为下标为i的元素
	largest := i
	lson := 2*i + 1 // 左孩子下标
	rson := 2*i + 2 // 右孩子下标
	if lson < n && arr[largest] < arr[lson] {
		largest = lson
	}
	if rson < n && arr[largest] < arr[rson] {
		largest = rson
	}
	// 最大值不是i, 则交换值。交换完之后，子节点同样要满足堆性质，于是递归该下标
	if largest != i {
		arr[largest], arr[i] = arr[i], arr[largest]
		heapify(arr, n, largest)
	}
}

func buildHeap(arr []int) {
	n := len(arr)
	for i := n/2 - 1; i >= 0; i-- {
		heapify(arr, n, i)
	}
}

func HeapSort(arr []int) {
	n := len(arr)
	buildHeap(arr)
	for i := n - 1; i > 0; i-- {
		arr[0], arr[i] = arr[i], arr[0]
		heapify(arr, i, 0)
	}
}

func main() {
	arr := []int{10, 2, 4, 1, 9, 11, 8, 5, 13, 12, 6, 3, 7, 15, 14}
	fmt.Println("排序前:", arr)
	HeapSort(arr)
	fmt.Println("排序后", arr)
}

运行结果：

排序前: [10 2 4 1 9 11 8 5 13 12 6 3 7 15 14]
排序后 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]