大根堆，小根堆的实现,java内置优先级队列使用

大根堆和小根堆可以容易获取数据结构内最大值、最小值的数据结构，在很多地方上都有应用。
理解：

• 大根堆/小根堆，是一棵完全二叉树。特点是节点都大于/小于它的孩子节点。
• 每次弹出元素的时候，总是从树的最顶端弹出，因此每次都可以获取该二叉树的最大/最小值。

实现思路：

• 因为大根堆/小根堆必须符合树的根节点是整棵树的最大/最小值，因此每次从树取出值获取往树里面加入一个值，都要将树进行堆化，让树重新符合堆的性质。
• 可以用数组实现堆，给二叉树按层次从0开始进行标号，刚好每个节点的左孩子节点下标等于自己节点下标*2+1，有孩子节点下标等于自己节点下标*2+2.
• 加入节点的时候，一般从数组的末端，也就是树的最后面加入元素。然后从加入节点开始一直和父节点做比较，如果该节点大于父节点，就交换该节点值和父节点值，如果不大于父节点，就堆化恢复完成。
• 弹出节点的时候可以先将最后一个节点和根节点进行交换，然后删除最后一个节点，再从根结点向下修复堆。每次都取孩子节点大的那一个与自己比较，如果孩子节点比自己大，就将自己节点与孩子节点互换，然后孩子节点就是需要调整的节点，同理进行调整，一直到当前节点大于两个孩子节点，或者当前节点没有孩子节点为止。

实现代码：

public class BigHeap {
    List<Integer> list;
    //constructor
    public BigHeap() {
        list=new ArrayList<>();
    }
    //get left child's index
    public int getLeft(int index){
        return index*2+1;
    }
    //get right child's index
    public int getRight(int index){
        return index*2+2;
    }
    //get parents' index
    public int getpar(int index){
        return (index-1)/2;
    }
    //insert num
    public void push(int num){
        int size=list.size();
        list.add(size,num);
        fixRear(list.size()-1);
    }
    //get num
    public int pop(){
        int res=-1;
        if(list.size()==0){
            throw new RuntimeException("队列里没有数据");
        }
        res=list.get(0);
        if(list.size()==1){
            list.remove(0);
        }else{
            int rear=list.size()-1;
            Collections.swap(list,0,rear);
            list.remove(rear);
            fixHead(0);
        }
        return res;
    }
    //fix from head
    private void fixHead(int index){
        int changeNum;
        while(getLeft(index)<list.size()){
            changeNum=getLeft(index);
            if((changeNum+1)<list.size()&&list.get(changeNum)<list.get(changeNum+1)){
                changeNum=changeNum+1;
            }
            if(list.get(index)<list.get(changeNum)){
                Collections.swap(list,index,changeNum);
            }else{
                break;
            }
            index=changeNum;
        }
    }
    //fix from rear
    private void fixRear(int index){
        while(index>0){
            if(list.get(index)>list.get(getpar(index))){
                Collections.swap(list,index,getpar(index));
            }else{
                break;
            }
            index=getpar(index);
        }
    }
}

java内置de优先级队列：
优先级队列就是用堆实现的，因此优先级队列只是出队是保持顺序，并非在队列里面就有序。
PriorityQueue，如果是存储整型数据，默认是出队顺序是从小到大。
如果需要改变顺序，可以使用compator表达式，在构造函数传入作为参数。

 PriorityQueue queue=new PriorityQueue<>((a,b)->a-b);
 //a和b做比较，小的在前。出队顺序从小到大
  PriorityQueue queue=new PriorityQueue<>((a,b)->b-a);
 //a和b做比较，大的在前。出队顺序从大到小
 PriorityQueue<Node> queue=new PriorityQueue<>((a,b)->b.age-a.age);
 //以Node对象的age属性做比较，出队顺序从大到小
 PriorityQueue<Node> queue=new PriorityQueue<>((a,b)->a.age-b.age);
 //以Node对象的age属性做比较，出队顺序从小到大