优先队列的简单实现

package com.yyy;
 
//继承Comparable接口，给每个数据提供比较规则
public class MaxPriorityQueue<T extends Comparable<T>> {
    //记录堆中元素的个数
    private int N;
    //记录堆中元素的个数
    private T[] items;
    //创建容量为capacity的MaxPriorityQueue对象
    public MaxPriorityQueue(int capacity){
        this.N=0;
        this.items = (T[]) new Comparable[capacity + 1];
    }
    //判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i,int j){
        return items[i].compareTo(items[j])<0;
    }
    //交换堆中i索引和j索引处的值
    private void exch(int i,int j){
        T tmp = items[i];
        items[i]=items[j];
        items[j]=tmp;
    }
    //删除队列中最大的元素，并返回这个最大元素
    public T delMax(){
        if(N==0){
            return null;
        }
        T max=  items[1];
        exch(1,N);
        N--;//把最大的数据放到最后，最小的数据放到第一个结点，N--就删除了最后一个结点
        sink(1);//将换过来的结点进行下沉
        return max;
    }
    //往队列中插入一个元素
    public void insert(T t){
            items[++N]=t;
            swim(N);
    }
    //使用上浮算法，使索引k处的元素能处在一个正确的位置
    private void swim(int k){
        while(k>1){
            if(less(k/2,k)){
                exch(k/2,k);
            }
            k=k/2;
        }
    }
    //使用下沉算法，使索引K处元素处于一个正确的位置
    private void sink(int k){
        while (2*k<=N){
            //1.找出当前结点的较大的子结点
            int max;
            if(2*k+1<=N){
                if (less(2*k,2*k+1)){
                    max=2*k+1;
                }else{
                    max=2*k;
                }
            }else{
                max=2*k;
            }
            if(!less(k,max)){//k>=max,则退出
                break;
            }
            exch(k,max);
            k=max;
        }
    }
    //获取队列中元素的个数
    public int size(){
        return N;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return N==0;
    }
}