堆排序（heapSort）

堆可以分为大根堆和小根堆，是一个完全二叉树
堆排序是根据堆结构设计的一种排序
堆的分类：
大根堆：每个结点的值都大于其左孩子和右孩子结点的值
小根堆：每个结点的值都小于其左孩子和右孩子结点的值

数组中某元素的父结点和左右孩子结点，比如已知索引为i的数，那么
1）父结点索引：(i-1)/2
2）左孩子索引：2i+1
3）右孩子索引：2i+2

堆排序算法思路：
1.首先将数组构造成一个大根堆，堆结构的顶端值为整个数组的最大值
2.将顶端的数与末尾的数交换，此时，末尾的数为最大值，剩余待排序数组个数为 size - 1
3.将剩余的 size - 1 个数再构造成大根堆，再将顶端数与 size - 1 位置的数交换，如此反复执行，便能得到有序数组

平均时间复杂度：O(nlogn)
初始化建堆：O(n)
排序重建堆：O(nlog(n))
总复杂度：O(n+nlogn)=O(nlogn)
空间复杂度：O(1)
稳定性：不稳定，非堆顶元素在向堆顶移动的过程中，经历着堆层次的改变，这就有可能导致相等元素相对位置的改变
适合场景：待排序序列中元素个数较多，堆排序效率较高。

package main

import "fmt"

func main() {
	arr := []int{1, 3, 6, 5, 2, 8}
	heapSort(arr)
	for _, v := range arr {
		fmt.Println(v)
	}
}

// 堆排序：
func heapSort(arr []int) {
	// 所有元素入堆
	/*// 自上而下建堆：O(nlogn)
	for i := 0; i < len(arr); i++ {
		heapInsert(arr, i)
	}*/
	// 自下而上建堆：O(n)
	for i := len(arr) - 1; i >= 0; i-- {
		heapify(arr, i, len(arr))
	}
	// 将首元素(最大值元素)弹出(与尾值交换)
	size := len(arr)
	arr[0], arr[size-1] = arr[size-1], arr[0]
	size--
	// 不断弹出最大元素，完成排序：
	for size > 0 {
		heapify(arr, 0, size)
		arr[0], arr[size-1] = arr[size-1], arr[0]
		size--
	}
}

// 新元素插入堆操作：向上操作
func heapInsert(arr []int, index int) {
	for arr[index] > arr[(index-1)/2] {
		arr[index], arr[(index-1)/2] = arr[(index-1)/2], arr[index]
		index = (index - 1) / 2
	}
}

// 剩余元素重新成堆：向下操作
func heapify(arr []int, index, size int) {
	left := 2*index + 1
	for left < size {
		right := left + 1
		largest := left
		if right < size && arr[right] > arr[left] {
			largest = right
		}
		if arr[index] > arr[largest] {
			largest = index
		}
		if largest == index {
			break
		}
		arr[largest], arr[index] = arr[index], arr[largest]
		index = largest
		left = 2*index + 1
	}
}