最大、最小优先队列的Java实现

一.最大优先队列

1.概念
普通的队列是一种先进先出(尾插头取)的数据结构,元素在队列尾追加,而从队列头删除。
在某些情况下,我们可能需要找出队列中的最大值或者最小值,例如使用一个队列保存计算机的任务,一般情况下计算机的任务都是有优先级的,我们需要在这些计算机的任务中找出优先级最高的任务先执行,执行完毕后就需要把这个任务从队列中移除

普通的队列要完成这样的功能,需要每次遍历队列中的所有元素,比较并找出最大值,效率不是很高,这个时候,我们就可以使用一种特殊的队列来完成这种需求,优先队列,需要基于的思想来实现。
的特性,其最大值在根节点处,每次将根节点取出,就相当于是获取了优先级最大的数。
最大优先队列的实现代码与堆的实现代码基本一致,底层同样是使用了数组。重点是理解swim sink delMax方法的逻辑即可。
堆的Java实现

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

2.实现

public class MaxPriorityQueue<T extends Comparable> { //最大优先队列
    private T[] items; //优先队列基于堆的结构来实现,所以也用数组
    private int N;

    public MaxPriorityQueue(int capacity) {
        this.N = 0;
        this.items = (T[]) new Comparable[capacity + 1]; //会废弃掉0索引
    }


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

    private boolean more(int i, int j) {
        return (items[i].compareTo(items[j]) > 0);
    }

    public void insert(T t) {
        items[++N] = t; //使用++N能废弃掉0索引;新加入的元素索引为N
        swim(N); //对索引N的元素使用上浮方法使其有序
    }

    public T delMax() {
        T max = items[1]; //仅记录要删除的最大元素
        swap(1, N);// 将最大元素和索引N处元素交换
        items[N] = null; //删除最大元素
        N--;
        sink(1);  // 通过sink方法让堆变得有序
        return max;
    }

    private void swim(int k) { //上浮,和父节点比较!
        while (k > 1) { //如果k已经到了根节点,则不再需要循环
            if (more(k, k / 2)) {  //如果当前k处结点大于其父结点,则交换
                swap(k, k / 2);
                k = k / 2;
            } else {   //如果当前k处结点小于其父结点,则跳出循环
                break;
            }
        }
    }

    private void sink(int k) { //下沉,和子节点的较大值比较!
        int max;
        while (2 * k <= N) { //k存在左子节点 ,若不存在左子结点2k,也不会存在右子节点2k+1 了!
            if (2 * k + 1 <= N) { //且存在右子节点
                //找出左右子节点的最大
                if (more(2 * k, 2 * k + 1)) { //如果左大于右
                    max = 2 * k;
                } else {
                    max = 2 * k + 1;
                }

            } else { //只有左子结点
                max = 2 * k;
            }

            //比较当前k结点和max
            if (!more(k, max)) {
                swap(k, max);//k小于子节点中最大,则交换
                k = max;
            } else {
                break;
            }
        }
    }


    public int size() {
        return N;
    }


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


    public static void main(String[] args) {
        MaxPriorityQueue<String> p = new MaxPriorityQueue<>(20);
        p.insert("A");
        p.insert("B");
        p.insert("C");
        p.insert("D");
        p.insert("E");
        p.insert("F");
        p.insert("G");

        while (!p.isEmpty()) {
            String s = p.delMax();
            System.out.print("删除当前最大:"+s + "\n");
        }
    }
}

测试部分中,每一轮循环输出当前优先级队列中的最大值,输出结果:

删除当前最大:G
删除当前最大:F
删除当前最大:E
删除当前最大:D
删除当前最大:C
删除当前最大:B
删除当前最大:A

二.最小优先队列
最小优先队列的实现逻辑和最大优先队列的基本一样。只是将more换成了less
前面学习堆的时候,堆中存放数据元素的数组要满足都满足如下特性:
1.最大的元素放在数组的索引1处。
2.每个结点的数据总是大于等于它的两个子结点的数据。

最大优先队列的swim和sink:
上浮:将当前结点k和父节点作比较,若k结点大于父结点,则交换k和父节点
下沉:求出当前结点的两个子节点的最大值max,若当前结点k小于max,则交换max和k
(数据大的往前放)

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

最小优先队列的swim和sink
上浮:将当前结点k和父节点作比较,若k结点小于父结点,则交换k和父节点
下沉:求出当前结点的两个子节点的最小值min,若当前结点k大于min,则交换min和k
(数据小的往前放)

实现:

public class minPriorityQueue<T extends Comparable> {

    private T[] items; //优先队列基于堆的结构来实现,所以也用数组
    private int N;

    public minPriorityQueue(int capacity) {
        this.N = 0;
        this.items = (T[]) new Comparable[capacity + 1]; //会废弃掉0索引
    }


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

    private boolean less(int i, int j) { //比较
        return (items[i].compareTo(items[j]) <0);
    }

    public void insert(T t) {
        items[++N] = t; //使用++N能废弃掉0索引;新加入的元素索引为N
        swim(N); //对索引N的元素使用上浮方法使其有序
    }

    public T delMin() {
        T min = items[1]; //仅记录要删除的最大元素
        swap(1, N);// 将最小元素和索引N处元素交换
        items[N] = null; //删除最小元素
        N--;
        sink(1);  // 通过sink方法让堆变得有序
        return min;
    }

    private void swim(int k) {
        while (k > 1) { //如果k已经到了根节点,则不再需要循环
            if (less(k, k / 2)) { //如果当前结点k小于父结点,则交换
                swap(k, k / 2);
                k = k / 2;
            } else {
                break;
            }
        }
    }

    private void sink(int k) {
        int min;
        while (2 * k <= N) { //k存在左子节点
            if (2 * k + 1 <= N) { //且存在右子节点
                //找出左右子节点的最小
                if (less(2 * k, 2 * k + 1)) { //如果左小于右
                    min = 2 * k;
                } else {
                    min = 2 * k + 1;
                }

            } else { //只有左子结点
                min = 2 * k;
            }

            //比较当前k结点和max
            if (!less(k, min)) {
                swap(k, min);//当前结点k大于子节点中最小,则交换
                k = min;
            } else {
                break;
            }
        }
    }


    public int size() {
        return N;
    }


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

    public static void main(String[] args) {
        minPriorityQueue<String> p = new minPriorityQueue<String>(20);
        p.insert("A");
        p.insert("B");
        p.insert("C");
        p.insert("D");
        p.insert("E");
        p.insert("F");
        p.insert("G");

        while (!p.isEmpty()) {
            String s = p.delMin();
            System.out.print(s + " ");
        }
    }
}

测试结果:(小的优先取出) A B C D E F G

你可能感兴趣的:(数据结构与算法,数据结构)