优先队列:最大优先队列、最小优先队列(堆实现)

0 优先队列

  1. 普通队列先进先出,队尾加,队头删;
  2. 某些情况下,我们需要找出队列中的最大值或最小值。比如使用一个队列保存计算机的任务,任务需要有优先级,我们需要找出优先级最高的任务先执行,执行完毕后将任务从队列删除。
  3. 普通队列完成任务,需要遍历队列所有元素,比较并找出最大值,效率低下;
  4. 这时可以使用一种特殊的队列来完成需求,即优先队列。
  5. 按照功能需求分两种:1 最大优先队列:获取并删除队列中最大的值;2 最小优先队列:获取并删除队列中最小的值。

1 最大优先队列

由于堆可以很方便地删除最大值,因此基于堆实现最大优先队列。

Java实现:

public class MaxPriorityQueue<T extends Comparable<T>> {
    //存储堆中的元素
    private T[] items;
    //记录堆中元素的个数
    private int N;

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

    //获取队列中元素的个数
    public int size() {
        return N;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return N==0;
    }

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

    //删除堆中最大的元素,并返回这个最大元素
    public T delMax() {
        T max = items[1];
        exch(1,N);
        items[N] = null;
        N--;
        sink(1);
        return max;
    }

    //使用上浮算法,使索引k处的元素能在堆中处于一个正确的位置
    private void swim(int k) {
        while(k>1){
            if (less(k/2,k)){
                exch(k/2,k);
            } else {
                break;
            }
            k = k/2;
        }
    }

    //使用下沉算法,使索引k处的元素能在堆中处于一个正确的位置
    private void sink(int k) {
        while(2*k<=N){
            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)){
                break;
            }
            exch(k,max);
            k = max;
        }
    }

    //判断堆中索引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 class Test {
    public static void main(String[] args) {
        String[] arr = {"S","O","T","E","X","A","M","P","L","E"};
        MaxPriorityQueue<String> maxpq = new MaxPriorityQueue<>(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 + ",");
        }
    }
}
10
X,T,S,P,O,M,L,E,E,A,

2 最小优先队列

最大优先队列基于堆的思想实现,堆中存放数据的数组满足如下两个特性:

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

为了实现最小优先队列,我们可以用相反的思想实现最小堆,使堆中存放数据的数据满足如下两个特性:

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

Java代码实现:

public class MinPriorityQueue<T extends Comparable<T>> {
    //存储堆中的元素
    private T[] items;
    //记录堆中元素的个数
    private int N;

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

    //获取队列中元素的个数
    public int size() {
        return N;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return N == 0;
    }

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

    //删除堆中最小的元素,并返回这个最小元素
    public T delMin() {
        T min = items[1];
        exch(1,N);
        items[N] = null;
        N--;
        sink(1);
        return min;
    }

    //使用上浮算法,使索引k处的元素能在堆中处于一个正确的位置
    private void swim(int k) {
        //通过循环比较当前结点和其父结点的大小
        while(k>1){
            if (less(k,k/2)){
                exch(k,k/2);
            } else {
                break;
            }
            k = k/2;
        }
    }

    //使用下沉算法,使索引k处的元素能在堆中处于一个正确的位置
    private void sink(int k) {
        //通过循环比较当前结点和其子结点中的较小值
        while(2*k<=N){
            //1.找到子结点中的较小值
            int min;
            if (2*k+1<=N){
                if (less(2*k, 2*k+1)){
                    min = 2*k;
                }else{
                    min = 2*k+1;
                }
            }else{
                min = 2*k;
            }
            //2.判断当前结点和较小值的大小
            if (!less(min,k)){
                break;
            }
            exch(k,min);
            k = min;
        }
    }

    //判断堆中索引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 class Test {
    public static void main(String[] args) {
        String[] arr = {"S","O","T","E","X","A","M","P","L","E"};
        MinPriorityQueue<String> minpq = new MinPriorityQueue<>(20);
        for (String s: arr) {
            minpq.insert(s);
        }
        System.out.println(minpq.size());
        String del;
        while(!minpq.isEmpty()) {
            del = minpq.delMin();
            System.out.print(del + ",");
        }
    }
}
10
A,E,E,L,M,O,P,S,T,X,
  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hellosc01

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值