二叉堆

二叉堆

本文要说的不是堆栈的堆，而是数据结构中的堆。
堆又被称作为优先队列。队列是FIFO的数据结构，堆也可以看作是一种FIFO的数据结构，不同的是，堆可以被看作是有优先级的，比如小根堆，总是关键字最小的节点为队首。
思考一个问题：
一个打印机内部维护一个队列，把需要处理的文件都交给队列处理，那么可能现在出现一种情况是，先来的作业需要打印100张，后来的只需要打印一张，常理之下，我们可能会让打印1张的先进行打印，但是，队列是FIFO的，那么后来的那一张就会等待前面的100张打印完毕后才会开始打印。
堆就不一样了，可以维护一个小根堆，那么打印一张的作业就算后来，也会因此被首先打印。

堆是一颗完全二叉树，前n - 1层都是被填满的，n层的节点从左到右被填满。那么我们可以用一个数组来进行存储，而不是用链。

堆的插入

往堆中插入元素时，需要将元素插至该堆的最后一个节点，随后通过与父节点的关键字进行对比，进行percolate（上滤）操作。

现在有这么一个堆

现在要插入一个元素2，那么它应该是这样的

通过跟父元素关键字的对比，然后进行上滤操作

这样最关键字最小的元素就会浮动到最顶层。

下面来看一下具体实现（golang描述）

首先需要定义一个堆的结构体

type Heap struct {
    arr []int
}

//Heap构造函数
func NewHeap() *Heap{
    return &Heap{
        arr: make([]int, 0, 10),
    }
}

插入函数

//往堆中插入元素
func (h *Heap) insert(v int) bool{
    if len(h.arr) == 0 { 
        h.arr = append(h.arr, 0)
        h.arr = append(h.arr, v); 
        return true
    }
    //空穴位置
    var hole int
    //判断是否还有空间
    h.arr = append(h.arr, 0)
    hole = len(h.arr) - 1 
    fmt.Printf("evaluted  %d\n",hole)
    //上滤 percolate up
    for ; hole > 1 && h.arr[hole / 2] > v; hole /= 2 {
        h.arr[hole] = h.arr[hole / 2]
    }

    h.arr[hole] = v
    return true
}

可以借助插入函数来初始化一个堆

//初始化堆
func (h *Heap) init(vals...int){
    for _, v := range vals {
        h.insert(v)
    }
} 

执行

col := []int{13, 21, 16, 24, 31}
h := NewHeap()
h.init(col...)
h.insert(2)
fmt.Println(h.arr) //[0 2 21 13 24 31 16]

堆的删除

现在如果我们要删除一个堆顶节点呢？

很常见的一个方法是，将堆的最后一个元素提到删除的空位上来，然后将这个元素进行下滤操作。

比如现在将关键字为2的这个节点从堆中删除。
首先就得先将最后一个节点提到删除的空位上来

然后再进行下滤操作，跟子节点中最小的节点的关键字进行比较。

下面给出一个具体实现

//删除元素
func (h *Heap) deleteMin() bool{
    var ok bool
    if len(h.arr) == 0 { 
        return false 
    } else if len(h.arr) == 2 {
        h.arr, ok = sliceRemoveEle(h.arr, h.arr[1])
        if !ok {return false}
        return true
    }

    //删除最小元素
    h.arr[1] = h.arr[len(h.arr) - 1]
    h.arr = h.arr[:len(h.arr) - 1]
    //下滤 percolate down
    index := 1
    for index * 2 < len(h.arr) {
        var minNodeIndex int
        if index * 2 + 1 > len(h.arr) { 
            if h.arr[index * 2] < h.arr[index] {
                h.arr[index * 2], h.arr[index] = h.arr[index], h.arr[index * 2]
                index *= 2
                break
            }
        }


        if h.arr[index * 2] > h.arr[index * 2 + 1] {
            minNodeIndex = index * 2 + 1
        } else {
            minNodeIndex = index * 2
        }

        fmt.Println(h.arr[minNodeIndex], h.arr[index])

        if h.arr[minNodeIndex] < h.arr[index] {
            h.arr[minNodeIndex], h.arr[index] = h.arr[index], h.arr[minNodeIndex]
            index = minNodeIndex
        } else {
            break
        }

    }

    return true
}

执行

func main(){
    col := []int{13, 21, 16, 24, 31}
    h := NewHeap()
    h.init(col...)
    h.insert(2)
    h.deleteMin()
    fmt.Println(h.arr) //[0 13 21 16 24 31]
}