数据结构-堆

堆

概念

性质：一颗完全二叉树，父节点>=或者<=任意子节点，子节点间的关系不做要求

形式：大顶堆-根节点最大，小顶堆-根节点最小

小顶堆

大顶堆

基本操作：添加数据（上滑），删除数据（下滑）

添加：在数组最后添加一个元素，比较该元素与其父节点是否符合堆的性质即大小关系,如果不符合关系就交换两个的值，并向上继续比较。

    /**
     * 为了方便计算，从下标1开始存入数据
     * 下标n的节点的父节点为n/2，左孩子n*2。右孩子n*2+1
     */
    int data[]; 
    int size = 1; //data的数据长度
    void add(int newData){
        data[size] = newData;
        _up(size); //小顶堆
        size++;
    }
    private void _up(int nodeIndex) {
        if(nodeIndex>1){
            int p = nodeIndex/2;
            if(data[p]<data[nodeIndex]) { //若是小顶堆，方向相反
                swap(p,nodeIndex);
                _up(p);
            }
        }
    }

删除：删除根节点，将最后一个节点移动到员根节点的位置，比较新的根节点与两个孩子节点，求出最大值或者最小值，查看是否需要调整。重复此操作

    int delete(){
        int tmp = data[1];
        data[1] = data[--size];
        _down(1);
        return tmp;
    }
    private void _down(int i) {
        int l = i*2;
        int r = l+1;
        int min = i;
        if(l<size){
            if(data[l]<data[min]) min = l; //大顶堆，方向相反
            if(r<size&&data[r]<data[min]) min = r; //大顶堆，方向相反
            if( min == i) return;
            swap(i,min);
            _down(min);
        }
    }

应用：1.快速得到最大值，或者最小值. 2.在队列变化时，求第n个数(对前n-1个数建立堆，新来一个元素后，根据堆内数据的个数进行判断是否添加到堆内)

public class Heap {
    public Heap(int size) {
            data = new int[size+1];
    }
    /**
     * 为了方便计算，从下标1开始存入数据
     * 下标n的节点的父节点为n/2，左孩子n*2。右孩子n*2+1
     */
    int data[]; 
    int size = 1; //data的数据长度
    void add(int newData){
        data[size] = newData;
        _up(size); //小顶堆
        size++;
    }
    private void _up(int nodeIndex) {
        if(nodeIndex>1){
            int p = nodeIndex/2;
            if(data[p]>data[nodeIndex]) { //大顶堆，方向相反
                swap(p,nodeIndex);
                _up(p);
            }
        }
    }
    //
    private void up(int nodeIndex) {
        while(nodeIndex>1){
            int p = nodeIndex/2;
            if(data[p]>data[nodeIndex]) {//大顶堆，方向相反
                swap(p,nodeIndex);
                nodeIndex = p;
            }
            if(p!=nodeIndex) return;
        }
    }

    int delete(){
        int tmp = data[1];
        data[1] = data[--size];
        _down(1);
        return tmp;
    }
    private void _down(int i) {
        int l = i*2;
        int r = l+1;
        int min = i;
        if(l<size){
            if(data[l]<data[min]) min = l; //大顶堆，方向相反
            if(r<size&&data[r]<data[min]) min = r; //大顶堆，方向相反
            if( min == i) return;
            swap(i,min);
            _down(min);
        }
    }
    private void down(int i) {
        int l = i*2;
        int r = l+1;
        int min;
        while(l<size){
            min = i;
            if(data[l]<data[min]) min = l; //大顶堆，方向相反
            if(r<size&&data[r]<data[min]) min = r; //大顶堆，方向相反
            if( min == i) return;
            swap(i,min);
            i = min;
            l = i*2;
            r = l+1;
        }
    }
    private void swap(int a, int b) {
        int tmp = data[a];
        data[a] = data[b];
        data[b] = tmp;
    }
}