数据结构——优先队列

优先队列的概念

普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在某些情况下，我们可能需要找出队列中的最大值或者最小值，例如使用一个队列保存计算机的任务，一般情况下计算机的任务都是有优先级的，我们需要在这些计算机的任务中找出优先级最高的任务先执行，执行完毕后就需要把这个任务从队列中移除。普通的队列要完成这样的功能，需要每次遍历队列中的所有元素，比较并找出最大值，效率不是很高，这个时候，我们就可以使用一种特殊的队列来完成这种需求，优先队列。

优先队列按照其作用不同，可以分为以下两种：
1.最大优先队列：可以获取并删除队列中最大的值
2.最小优先队列：可以获取并删除队列中最小的值

最大优先队列

堆这种结构是可以方便的删除最大的值，所以，我们可以基于堆区实现最大优先队列。

最大优先队列API设计

 最大优先队列的代码实现

public class MaxPriority<T extends Comparable<T>>{
    private T[] items;//用来存储元素的数组
    private int N; //记录堆中元素的个数
    public MaxPriority(int capacity){
        this.items=(T[])new Comparable[capacity+1];
        this.N=0;
    }

    //判断堆中索引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 temp=items[i];
        items[i]=items[j];
        items[j]=temp;
    }
    //删除队列中最大的元素，并返回这个最大元素
    public T delMax(){
      T max=items[1];
      //交换索引1和索引N处的值
      exch(1,N);
      //删除最后位置上的元素
      items[N]=null;
      N--;//元素个数-1
      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){
            //找到子结点中的较大者
            int max=2*k;
            if(2*k+1<=N){
                if(less(2*k,2*k+1)){
                    max=2*k+1;
                }else{
                    max=2*k;
                }
            }
            //比较当前结点和子结点中的较大者，如果当前结点不小，则结束循环
            if(!less(k,max)){
                break;
            }
            //当前结点小，则交换
            exch(k,max);
            k=max;
        }
    }
    //获取队列中元素的个数
    public int size(){
        return N;
    }
    //判断队列是否为空
    public boolean isEmpty(){
         return N==0;
    }
}

//测试代码
public class MaxPriorityTest {
    public static void main(String[] args){
        MaxPriority<String> mp=new MaxPriority<>(10);
        mp.insert("A");
        mp.insert("B");
        mp.insert("D");
        mp.insert("C");
        mp.insert("A");
        while(!mp.isEmpty()){
            String s = mp.delMax();
            System.out.print(s+" ");
        }
    }
}

最小优先队列

我们之前实现的堆可以把它叫做最大堆，我们可以用相反的思想实现最小堆，让堆中存放数据元素的数组满足如下特性：
1.最小的元素放在数组的索引1处
2.每个结点的数据总是小于等于它的两个子结点的数据

最小优先队列API设计

 最小优先队列代码实现

public class MinPriorityQueue <T extends Comparable<T>> {
    private T[] items;
    private int N;
    public MinPriorityQueue(int capacity){
        this.items=(T[])new Comparable[capacity];
        this.N=0;
    }
    //判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i,int j){
        return items[i].compareTo(items[j])<0;
    }
    //交换堆中i索引和j索引处的值
    public void exch(int i,int j){
        T temp=items[i];
        items[i]=items[j];
        items[j]=temp;
    }
    //获取队列中元素的个数
    public int size(){
        return N;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return N==0;
    }
    //删除队列中最小的元素，并返回这个最大元素
    public T delMin(){
        T min=items[1];
        exch(1,N);
        items[N]=null;
        N--;
        sink(1);
        return min;
    }
    //往队列中插入一个元素
    public void insert(T t){
        items[++N]=t;
        swim(N);
    }
    //使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
    public void swim(int k){
         while(k>1){
             if(less(k,k/2)){
                 exch(k,k/2);
             }
             k=k/2;
         }
    }
    //使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
    public void sink(int k){
       while(2*k<=N){
           int min=2*k;
           if(2*k+1<=N){
               if(less(2*k,2*k+1)){
                   min=2*k;
               }else{
                   min=2*k+1;
               }
           }
           if(less(k,min)){
               break;
           }
           exch(k,min);
           k=min;
       }
    }
}

//测试代码
public class MinPriorityTest {
    public static void main(String[] args){
        MinPriorityQueue<String> minq=new MinPriorityQueue<>(10);
        minq.insert("A");
        minq.insert("C");
        minq.insert("Q");
        minq.insert("B");
        minq.insert("H");
        while(!minq.isEmpty()){
            String s = minq.delMin();
            System.out.print(s+" ");
        }
    }
}