优先队列

最大优先队列,堆实现

public class MaxPriorityQueue<T extends Comparable<T>> {

    private T items[];
    private int size;

    public MaxPriorityQueue(int capacity){
        this.items = (T[])new Comparable[capacity+1];
        this.size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public boolean less(int i, int k){
        return items[i].compareTo(items[k]) < 0;
    }

    public void exchange(int i, int k){
        T tmp = items[i];
        items[i] = items[k];
        items[k] = tmp;
    }

    public void insert(T value){
        items[++size] = value;
        swim(size);
    }
	//上浮
    private void swim(int k) {
        while(k > 1){
            if(less(k/2, k)){
                exchange(k/2, k);
            }
            k /= 2;
        }
    }

    public T delMax(){
        T max = items[1];
        exchange(1, size);
        items[size] = null;
        size--;
        sink(1);
        return max;
    }
	//下沉
    private void sink(int k) {
        while(2*k<=size){
            int max = 0;
            if(2*k+1 <= size){
                if(less(2*k,2*k+1)){
                    max = 2*k+1;
                }else{
                    max = 2*k;
                }
            }else{
                max = 2*k;
            }
            if(!less(k,max)) break;
            exchange(k,max);
            k = max;
        }
    }
}

最小优先队列

public class MinPriorityQueue<T extends Comparable<T>> {

    private T items[];
    private int size;

    public MinPriorityQueue(int capacity){
        this.items = (T[])new Comparable[capacity+1];
        this.size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public boolean less(int i, int k){
        return items[i].compareTo(items[k]) < 0;
    }

    public void exchange(int i, int k){
        T tmp = items[i];
        items[i] = items[k];
        items[k] = tmp;
    }

    public void insert(T value){
        items[++size] = value;
        swim(size);
    }

    private void swim(int k){
        while(k > 1){
            if(!less(k/2, k)){
                exchange(k/2,k);
            }
            k /= 2;
        }
    }

    public T delMin(){
        T min = items[1];
        exchange(1, size);
        items[size] = null;
        size--;
        sink(1);
        return min;
    }

    public void sink(int k){
        while(2*k<=size){
            int min = 0;
            if(2*k+1<=size){
                if(less(2*k,2*k+1)){
                    min = 2*k;
                }else{
                    min = 2*k+1;
                }
            }else{
                min = 2*k;
            }

            if(less(k,min)) break;
            exchange(k,min);
            k = min;
        }
    }
}