Leetcode 优先队列详解

Posted 2023-03-30 若明天不见

优先队列

优先队列（Priority Queue）：一种特殊的队列。在优先队列中，元素被赋予优先级，当访问队列元素时，具有最高优先级的元素最先删除

普通队列详解Leetcode 队列详解

优先队列与普通队列最大的不同点在于出队顺序

• 普通队列的出队顺序跟入队顺序相关，符合「先进先出（First in, First out）」的规则。
• 优先队列的出队顺序跟入队顺序无关，优先队列是按照元素的优先级来决定出队顺序的。优先级高的元素优先出队，优先级低的元素后出队。优先队列符合 「最高级先出（First in, Largest out）」 的规则

适用场景

优先队列的应用场景非常多，比如：

• 数据压缩：赫夫曼编码算法
• 最短路径算法：Dijkstra 算法
• 最小生成树算法：Prim 算法
• 任务调度器：根据优先级执行系统任务
• 事件驱动仿真：顾客排队算法
• 排序问题：查找第 k 个最小元素

很多语言都提供了优先级队列的实现。比如，Java 的PriorityQueue，C++ 的priority_queue

Leetcode 真题

数组中的第K个最大元素

解题思路： 典型的优先队列/最大堆，依次入队排序后取队头的第K大的元素

public int findKthLargest(int[] nums, int k) 
    PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() 
        @Override
        public int compare(Integer o1, Integer o2) 
            return o1 - o2;
        
    );
    for (int num : nums) 
        if (queue.size() == k) 
            if (queue.peek() < num) 
                queue.poll();
                queue.offer(num);
            
         else 
            queue.offer(num);
        
    
    return queue.poll();

前 K 个高频元素

解题思路：使用优先队列记录出现次数topK
int[] 的第一个元素代表数组的值，第二个元素代表了该值出现的次数

public int[] topKFrequent(int[] nums, int k) 
    Map<Integer, Integer> occurrences = new HashMap<Integer, Integer>();
    for (int num : nums) 
        occurrences.put(num, occurrences.getOrDefault(num, 0) + 1);
    

    // int[] 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
    PriorityQueue<int[]> queue = new PriorityQueue<int[]>(new Comparator<int[]>() 
        public int compare(int[] m, int[] n) 
            return m[1] < n[1] ? -1 : 1;
        
    );
    for (Map.Entry<Integer, Integer> entry : occurrences.entrySet()) 
        int num = entry.getKey(), count = entry.getValue();
        if (queue.size() == k) 
            if (queue.peek()[1] < count) 
                queue.poll();
                queue.offer(new int[]num, count);
            
         else 
            queue.offer(new int[]num, count);
        
    
    int[] ret = new int[k];
    for (int i = 0; i < k; ++i) 
        ret[k - i - 1] = queue.poll()[0];
    
    return ret;

滑动窗口最大值

解题思路：使用优先队列记录窗口范围内的topK大数
int[] 的第一个元素代表数组的值，第二个元素代表了该值的下标
根据数组元素从大到小进行排序，若是元素相同的话，则根据下标进行从大到小进行排序

public int[] maxSlidingWindow(int[] nums, int k) 
	int[] result = new int[nums.length - k + 1];
	PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() 
		@Override
		public int compare(int[] o1, int[] o2) 
			return o1[0] == o2[0] ? o2[1] - o1[1] : o2[0] - o1[0];
		
	);

	for (int i = 0; i < k - 1; i++) 
		queue.offer(new int[]nums[i], i);
	
	for (int i = k - 1; i < nums.length; i++) 
		queue.offer(new int[]nums[i], i);
		// 若是优先队列/最大堆的堆顶元素 不在滑动窗口范围内，则直接从优先队列中进行删除
		while(queue.peek()[1] <= i - k)
			queue.poll();
		
		result[i - k + 1] = queue.peek()[0];
	
	return result;

---

参考资料：

1. 优先队列知识
2. Leetcode 队列详解

Java的优先队列PriorityQueue详解

一、优先队列概述

 

　　优先队列PriorityQueue是Queue接口的实现，可以对其中元素进行排序，

可以放基本数据类型的包装类（如：Integer，Long等）或自定义的类

对于基本数据类型的包装器类，优先队列中元素默认排列顺序是升序排列

但对于自己定义的类来说，需要自己定义比较器

二、常用方法

peek()//返回队首元素
poll()//返回队首元素，队首元素出队列
add()//添加元素
size()//返回队列元素个数
isEmpty()//判断队列是否为空，为空返回true,不空返回false

三、优先队列的使用

1.队列保存的是基本数据类型的包装类

//自定义比较器，降序排列
static Comparator<Integer> cmp = new Comparator<Integer>() {
      public int compare(Integer e1, Integer e2) {
        return e2 - e1;
      }
    };
public static void main(String[] args) {
        //不用比较器，默认升序排列
        Queue<Integer> q = new PriorityQueue<>();
        q.add(3);
        q.add(2);
        q.add(4);
        while(!q.isEmpty())
        {
            System.out.print(q.poll()+" ");
        }
        /**
         * 输出结果
         * 2 3 4 
         */
        //使用自定义比较器，降序排列
        Queue<Integer> qq = new PriorityQueue<>(cmp);
        qq.add(3);
        qq.add(2);
        qq.add(4);
        while(!qq.isEmpty())
        {
            System.out.print(qq.poll()+" ");
        }
        /**
         * 输出结果
         * 4 3 2 
         */
}

 

2.队列保存的是自定义类

//矩形类
class Node{
    public Node(int chang,int kuan)
    {
        this.chang=chang;
        this.kuan=kuan;
    }
    int chang;
    int kuan;
}

public class Test {
　　　　//自定义比较类，先比较长，长升序排列，若长相等再比较宽，宽降序
    static Comparator<Node> cNode=new Comparator<Node>() {
        public int compare(Node o1, Node o2) {
            if(o1.chang!=o2.chang)
                return o1.chang-o2.chang;
            else
                return o2.kuan-o1.kuan;
        }
        
    };
    public static void main(String[] args) {
        Queue<Node> q=new PriorityQueue<>(cNode);
        Node n1=new Node(1, 2);
        Node n2=new Node(2, 5);
        Node n3=new Node(2, 3);
        Node n4=new Node(1, 2);
        q.add(n1);
        q.add(n2);
        q.add(n3);
        Node n;
        while(!q.isEmpty())
        {
            n=q.poll();
            System.out.println("长: "+n.chang+" 宽：" +n.kuan);
        }
　　　　　/**
　　　　　　* 输出结果
　　　　　　* 长: 1 宽：2
　　　　　　* 长: 2 宽：5
　　　　　　* 长: 2 宽：3
　　　　　　*/
    }
}

 3.优先队列遍历

　　PriorityQueue的iterator（）不保证以任何特定顺序遍历队列元素。

　　若想按特定顺序遍历，先将队列转成数组，然后排序遍历

示例

Queue<Integer> q = new PriorityQueue<>(cmp);
        int[] nums= {2,5,3,4,1,6};
        for(int i:nums)
        {
            q.add(i);
        }
        Object[] nn=q.toArray();
        Arrays.sort(nn);
        for(int i=nn.length-1;i>=0;i--)
            System.out.print((int)nn[i]+" ");
        /**
         * 输出结果
         * 6 5 4 3 2 1 
         */

 

4.比较器生降序说明

Comparator<Object> cmp = new Comparator<Object>() {
        public int compare(Object o1, Object o2) {
            //升序
            return o1-o2;
            //降序
            return o2-o1;
        }
    };