优先队列的实现（无指针）

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

优先队列按照其作用不同，可以分为以下两种：

• 最大优先队列：可以获取并删除队列中最大的值
• 最小优先队列：可以获取并删除队列中最小的值

一、最大优先队列

之前学习过堆，而堆这种结构是可以方便的删除最大的值，所以，接下来我们可以基于堆实现最大优先队列。

代码实现（和堆的实现代码几乎完全相同）

package Heap;

import javax.swing.*;

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

    private T[] item; //存储堆中的元素
    private int n;  //记录堆中元素的个数

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

    public int size(){
        return n;
    }

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

    private boolean less(int i, int j){
        return item[i].compareTo(item[j]) < 0;
    }

    private void exch(int i, int j){
        T temp = item[i];
        item[i] = item[j];
        item[j] = temp;
    }

    //往堆中插入一个元素
    public void insert(T element){
        item[++n] = element;
        swim(n);
    }

    //上浮算法
    private void swim(int k){
        //如果是根节点就不再上浮了
        while (k > 1){
            if(less(k / 2, k)){
                //父节点小于当前结点就交换
                exch(k / 2, k);
            }
            k = k / 2; //更新当前结点的索引
        }
    }

    public T delMax(){
        T max = item[1];
        exch(1, n);
        //删除最后一个位置的元素
        item[n] = null;
        n--;
        sink(1);
        return max;
    }

    //下沉算法
    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;
                }
            }
            //比较当前结点和较大的子节点
            if (!less(k, max)){
                break;
            }
            exch(k, max);
            k = max;
        }
    }

}
public class PriorityQueueTest {
    public static void main(String[] args) {

        String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
        MaxPriorityQueue<String> maxpq = new MaxPriorityQueue<String>(20);
        for (String s : arr) {
            maxpq.insert(s);
        }
        System.out.println(maxpq.size());
        String del;
        while (!maxpq.isEmpty()){
            del = maxpq.delMax();
            System.out.print(del + " ");
        }
    }
}

二、最小优先队列

前面学习堆的时候，堆中存放数据元素的数组要满足都满足如下特性：

1. 最大的元素放在数组的索引1处。
2. 每个结点的数据总是大于等于它的两个子结点的数据。

其实之前实现的堆可以把它叫做最大堆，我们可以用相反的思想实现最小堆，让堆中存放数据元素的数组满足如下特性：

1.最小的元素放在数组的索引1处。
2.每个结点的数据总是小于等于它的两个子结点的数据。

代码实现：

package Heap;

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

    private T[] item; //存储堆中的元素
    private int n;  //记录堆中元素的个数

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

    public int size(){
        return n;
    }

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

    private boolean less(int i, int j){
        return item[i].compareTo(item[j]) < 0;
    }

    private void exch(int i, int j){
        T temp = item[i];
        item[i] = item[j];
        item[j] = temp;
    }

    //往堆中插入一个元素
    public void insert(T element){
        item[++n] = element;
        swim(n);
    }

    //上浮算法
    private void swim(int k){
        //如果是根节点就不再上浮了
        while (k > 1){
            if(less(k, k / 2)){
                //当前结点小于父节点就交换
                exch(k, k / 2);
            }
            k = k / 2; //更新当前结点的索引
        }
    }

    public T delMin(){
        T min = item[1];
        exch(1, n);
        //删除最后一个位置的元素
        item[n] = null;
        n--;
        sink(1);
        return min;
    }

    //下沉算法
    private void sink(int k){
        //叶节点不用下沉了
        while(2 * k <= n){
            //找子节点中的较大者
            int min = 2 * k;
            if(2 * k + 1 <= n && less(2 * k + 1, 2 * k)){ //存在右子节点
                min = 2 * k + 1;
            }
            //比较当前结点和较小的子节点
            if (less(k, min)){
                break;
            }
            //当前结点大，交换
            exch(k, min);
            k = min;
        }
    }
}
public class PriorityQueueTest {
    public static void main(String[] args) {

        String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
//        MaxPriorityQueue<String> maxpq = new MaxPriorityQueue<String>(20);
        MinPriorityQueue<String> minqueue = new MinPriorityQueue<String>(20);
        for (String s : arr) {
            minqueue.insert(s);
        }
        System.out.println(minqueue.size());
        String del;
        while (!minqueue.isEmpty()){
            del = minqueue.delMin();
            System.out.print(del + " ");
        }
    }
}

三、索引优先队列