堆

堆是什么

*堆是一种特殊的完全二叉树（每层都完全填慢，只有右边没填慢）

*所有的节点都大于等于（最大堆）或小于等于（最小堆）它的子节点

 

 

js中的堆

*js中通常用数组表示堆(index指的是元素在数组中的位置)

*左侧子节点的位置是2*index+1

*右侧子节点的位置是2*index+2

*父节点位置是（index-1）/2

堆的应用

*堆能高效。快速地找出最大值和最小值，时间复杂度O(1)

*找出第k个最大（小）元素

 最小堆

class MinHeap{
    constructor() {
        this.heap=[]
    }

    /**
     * 将值插入堆的底部，即数组的尾部
     * 然后上移：将这个值和它的父节点进行交换，直到父节点小于等于这个插入的值
     * 大小为k的堆中插入元素的时间复杂度为Ologk
     */
    swap(i1,i2){
        const temp =this.heap[i1]
        this.heap[i1]=this.heap[i2]
        this.heap[i2]=temp
    }
    getParentIndex(i){
       // return Math.floor((i-1)/2)
        return (i-1)>>1
    }

    shiftUp(index){
        if(index===0){return ;}
        const  parentIndex=this.getParentIndex(index)
        if(this.heap[parentIndex]>this.heap[index]){
            this.swap(parentIndex,index)
            this.shiftUp(parentIndex)
        }
    }
    insert(value){
        this.heap.push(value)
        this.shiftUp(this.heap.length-1)
    }
    /**
     *用数组尾部元素替换堆顶（直接删除堆顶会破坏结构）
     * 然后下移：将新的堆顶和它的子节点进行互换，直到子节点大于等于这个新堆顶
     * 大小为k的堆中删除堆顶的时间复杂度为O(logk)
     * */
    getLeftIndex(i){
        return i*2+1
    }
    getRightIndex(i){
        return  i*2+2
    }
    shiftDown(index){
        const leftIndex =this.getLeftIndex(index)
        const rightIndex =this.getRightIndex(index)
        if(this.heap[leftIndex]<this.heap[index]){
            this.swap(leftIndex,index)
            this.shiftDown(leftIndex)
        }
        if(this.heap[rightIndex]<this.heap[index]){
            this.swap(rightIndex,index)
            this.shiftDown(rightIndex)
        }

    }
    pop(){
        this.heap[0]=this.heap.pop()
        this.shiftDown(0)
    }

    /**
     * 获取堆顶和堆的大小
     * *获取堆顶：返回数组的头部
     * 获取堆的大小:返回数组的长度
     */
    peak(){
        return this.heap[0]
    }
    size(){
        return this.heap.length
    }
}
const h =new MinHeap()
h.insert(3)
console.log(h)
h.insert(2)
console.log(h)
h.insert(1)
console.log(h)
h.pop()
console.log(h)

 技术要点

+堆是一种特殊的完全二叉树

+所有的节点都大于等于（最大堆）或小于等于（最小堆）它的子节点

+堆能高效的，快速的找出最大值和最小值，时间复杂度O（1）

+找出第k个最大（小）元素