堆

定义

堆是一种特殊的树，满足以下两点要求的，我们称之为堆。

1. 堆是一个完全二叉树（完全二叉树的要求，除最后一层外，其他层的节点数都是满的，并且最后一层的节点都靠左排列）。
2. 堆中每个节点的值，都必须大于（或等于）其子树中每个节点的值。

对于每个节点都大于其子树节点值得堆（根节点最大）称为大顶堆，对每个节点都小于其子树接地那的堆（根节点最小）称为小顶堆。

实现

存储

因为堆是完全二叉树，所以堆用数组存储最节省空间，不需要存储额外的指针，而且根据数组下标，快速找到对应节点的左右子节点及父节点，如(习惯性堆从数组为1的下标开始存储，这样便于计算)：一个下标为i的节点，他的左子树为2*i，右子树为2*i+1，父节点为i/2

操作

插入元素

1. 把元素插入到堆的最后节点（按左排列的完全二叉树）。
2. 堆化。
   1. 堆化分为两种：从上到下堆化和从下到上堆化。
      1. 以大顶堆为例，插入是从下往上堆化：插入时，先将元素插入到堆的最后一个节点，然后这个节点在与其父节点做对比，当其不小于等于其父节点时，就与其父节点交换位置。重复这样比较交换工作，一直到符合小于等于其父节点即可。
      2. 以大顶堆为例，删除堆顶元素是从上往下堆化：删除堆顶元素后，为避免堆中的数据空洞，先将堆的最后一个元素，置为堆顶元素，然后在用堆顶元素跟其左节点比较，当其不大于等于其左子树时候，就跟其左子树互换位置，重复这样比较，置换操作，直到交换到最合适的位置即可。

删除堆顶元素

1. 直接用堆的最后一个叶子节点替换掉堆顶元素。此时已经删除了堆顶元素，元素长度维护减一。
2. 从堆顶第一个元素开始，逐步向下堆化：堆顶元素跟其左右节点比较，选择左右节点比其大的元素，与其交换，如此重复，将其堆化到其自己比左右子节点都大的合适位置即可。

建堆

步骤

1. 从第一个非叶子节点开始，及那个节点的堆n/2开始。
2. 逐步向前推进每个节点，从上到下进行堆化。

代码实现

package main

import "fmt"

type Heap struct {
	Data  []int
	N     int
	Count int
}

func NewHeap(c int) *Heap {
	return &Heap{
		Data:  make([]int, c+1),
		N:     c,
		Count: 0,
	}
}

func (this *Heap) Insert(v int) bool {
	if this.Count == this.N {
		return false
	}

	// 插入到最后一位
	this.Count++
	this.Data[this.Count] = v

	// 元素插入以后，从下自上进行堆化，以大顶堆为例
	child := this.Count
	parent := this.Count / 2
	for parent >= 1 && this.Data[parent] < this.Data[child] {
		this.Data[parent], this.Data[child] = this.Data[child], this.Data[parent]
		child = parent
		parent = child / 2
	}

	return true
}

func (this *Heap) RemoveMax() (bool, int) {
	if this.Count == 0 {
		return false, 0
	}

	res := this.Data[1]
	this.Data[1] = this.Data[this.Count]
	this.Count--

	this.Heapfiy(1)

	return true, res
}

// 注意体会maxPos指针的移动
func (this *Heap) Heapfiy(i int) {
	for {
		maxPos := i
		if 2*i <= this.Count && this.Data[maxPos] < this.Data[2*i] {
			maxPos = 2*i
		}
		if 2*i+1 <= this.Count && this.Data[maxPos] < this.Data[2*i+1] {
			maxPos = 2*i+1
		}
		if maxPos == i {
			break
		}
		this.Data[maxPos], this.Data[i] = this.Data[i], this.Data[maxPos]
		i = maxPos
	}
}

// 以大顶堆为例，从下往上堆化，一个无序数组直接堆化
func (this *Heap) buildHeap() {
	n := this.N
	if n <= 1 {
		return
	}

	// 1.获取第一个非叶子节点
	i := n / 2
	for ; i >= 1; i-- {
		j := i
		maxPos := j
		for maxPos <= n {
			if 2*j <= n && this.Data[2*j] > this.Data[j] {
				maxPos = 2 * j
			}
			if 2*j+1 <= n && this.Data[2*j+1] > this.Data[maxPos] {
				maxPos = 2*j + 1
			}
			if maxPos == j {
				break
			}
			this.Data[j], this.Data[maxPos] = this.Data[maxPos], this.Data[j]
			j = maxPos
		}
	}
}

func main() {
	//arr := []int{-1,7,5,19,8,4,1,20,13,16}
	heap := NewHeap(9)
	heap.Insert(7)
	heap.Insert(5)
	heap.Insert(19)
	heap.Insert(8)
	heap.Insert(4)
	heap.Insert(1)
	heap.Insert(20)
	heap.Insert(13)
	heap.Insert(16)

	fmt.Println(heap.Data)
	b, max := heap.RemoveMax()
	fmt.Printf("Remove : %v, max : %d, heap.Data : %v \n", b, max, heap.Data[1:heap.Count+1])

}

时间复杂度

一个包含 n 个节点的完全二叉树，树的高度不会超过 log2​n。堆化的过程是顺着节点所在路径比较交换的，所以堆化的时间复杂度跟树的高度成正比，也就是 O(logn)。插入数据和删除堆顶元素的主要逻辑就是堆化，所以，往堆中插入一个元素和删除堆顶元素的时间复杂度都是 O(logn)。

堆排序

// 堆排序
func (heap *Heap) sort()  {
	heap.buildHeap()
	k := heap.Count
	for k > 1 {
		heap.Data[1], heap.Data[k] = heap.Data[k], heap.Data[1]
		heap.Count--
		heap.Heapfiy(1)
		k--
	}
}

复杂度

时间复杂度

堆排序包括建堆和排序两个操作：

1. 建堆过程的时间复杂度是 O(n)
2. 排序过程的时间复杂度是 O(nlogn)

所以，堆排序整体的时间复杂度是 O(nlogn)。

空间复杂度

排序过程仅要极个别存储空间，所以为原地排序。

稳定性

因为堆排序时候，会将最后一个叶子节点跟顶点位置交换，这就有可能会改变相同元素（如果插入相同元素，则向插入普通元素一样，一直插入到叶子节点，统一更新为左孩子，在查找或者删除时候，查找到元素还不行，还需要一直查找到叶子节点，才算查找或者删除完整，因为插入相同节点，个人觉得，会破坏堆的定义，即子节点都大于或者小于其父节点，本篇就没有汇总。）的相对位置，所以堆排序是非稳定排序。

应用

优先级队列

堆就可以看成天然的优先级队列，只是概念上的区分而已，往堆中插入元素，就相当于优先级队列的元素入队。从堆顶取出元素，就相当于从优先级队列出队操作。

合并有序小文件

高性能定时器

队首存储下一次最先要执行的定时任务

TopK

求n个数中前k大的所有元素：维护k个元素的小顶堆，从代取数里，取出数据，比堆顶元素大的，删除堆顶元素，插入此值，进行堆化。比堆顶元素小的，直接抛弃即可，比较完所有元素，小顶堆中就是topK的数据集合。时间复杂度：n个数比较n，堆化为logK，所以时间复杂度为nlogK。