Java 优先队列PriorityQueue排序Pair

最新推荐文章于 2024-03-21 15:33:23 发布
原创 最新推荐文章于 2024-03-21 15:33:23 发布 · 1.5k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #算法

本文详细解释了如何使用lambda表达式重定义`PriorityQueue`的排序逻辑，从默认的值比较到根据需要实现的大于或小于操作。特别关注了如何在Java中调整`Pair`对象的优先级比较规则。

用lambda定义pair排序逻辑

 PriorityQueue<Pair<Integer,Integer>> q = 
            new PriorityQueue<Pair<Integer,Integer>>((a,b) -> a.getValue() - b.getValue());

这里(a,b) -> a.getValue() - b.getValue() 如果的逻辑是 返回值>0 则a大，否则b大

优先队列默认是小顶堆，最小元素在堆顶

如果要改变默认排序方式：

PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);

java栈队列优先队列算法
悦分享
07-01 484
java栈队列优先队列算法 栈 public class Solution { //将做方向的括号放入栈中 Stack<Character> stack = new Stack<Character>(); for( int i = 0 ; i < s.length() ; i ++ ) if( s.charAt(i) == ...
priority_queue（优先队列）的优先级设置
^.^
08-13 2564
基本数据类型的优先级设置： 对于基本数据类型（int,char,double），priority_queue的排序是默认是数值越大越优先。 #默认大根堆 priority_queue<int> que; #greater是小根堆 priority_queue<int,vector<int>,greater<int> > que; #less是大根堆 priority_queue<int,vector<int>,less<..
java中PriorityQueue优先级队列使用方法
soledede
06-25 568
优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。 　　PriorityQueue是从JDK1.5开始提供的新的数据结构接口。 　　如果不提供Comparator的话，优先队列中元素默认按自然顺序排列，也就是数字默认是小的在队列头，字符串则按字典序排列。        由于网上的资料大多将优先级队列各个方法属性，很少有实例讲解的，为方便大家以后使用，我...
java优先队列PriorityQueue
qq_43431863的博客
11-23 947
nums2中元素的顺序不能改变，因为计算结果的顺序依赖nums2的顺序，所以不能直接对nums2进行排序，用优先队列PriorityQueue给nums2降序排序 // 给 nums2 降序排序 PriorityQueue<int[]> maxpq = new PriorityQueue<>( (int[] pair1, int[] pair2) -> { return pair2[1] - pair1[1];//默认是小顶堆，
Java PriorityQueue实现Dijkastra 思路，解释，及代码
Ellie_Jin的博客
10-13 463
Dijkstra是用于求一个有权的有向或无向图中单源最短路径（一个节点到另一个节点）的算法。简单来说就是给你一个有权图，让你去求其中一个点到另一个点的一条路径的权值之和，并且这条路径的权值之和必须是所有可能的路径中最短的。如下图所示，Disjkstra就可以求点0到点1 2 3 4 5 6的最短路径。值得注意的是，如果是有负权存在，Dijkastra是用不了的。Diskastra实现首先我们需要考虑如何将这个图用代码实现，我这里会使用Edge和Graph类将整个图实现。
java pair排序_使用java 实现二次排序
weixin_36124631的博客
02-13 642
二次排序工具类：import java.io.Serializable;import scala.math.Ordered;/*** @author 作者 E-mail:* @version 创建时间：2017年8月30日 下午3:48:11* 类说明*///二次排序keypublic class SecondeIndexSort implements Ordered, Serializable{...
java pair排序_Java排序实现的心得分享
weixin_42501463的博客
02-13 734
1.概述排序和查找是程序设计里的两类非常基本的问题，而现在也存在很多经典的算法用于解决这两类问题，本文主要对java中排序算法实现进行一个基本的探讨，希望能够起到抛砖引玉的作用。在此之前，首先问各位几个问题：你能写出一个正确的快排吗？快排在什么情况下真正的快？你的快排足够快吗？还可以进一步优化吗？带着这些问题，我们来看看jre7中快排是如何实现的吧。Jre7中排序的实现类是DualPivotQui...
优先队列PriorityQueue (大根堆/小根堆/TopK问题)
love and share
05-27 4587
PriorityQueue是从JDK1.5开始提供的新的数据结构接口，它是一种基于优先级堆的极大优先级队列。优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。 默认情况下，PriorityQueue是小顶堆，如代码所示 public static void main(String[] args) { PriorityQueue<Integer> queue = new PriorityQueue<&g...
优先队列自定义排序
03-21 589
最近在做到一个业务的时候，对排序有特殊要求，要求a和b相绑定，先对a进行降序排序，如果a相同的情况下，需要也对b进行降序排序，这个明显是要自定义类来实现Comparable接口或Comparator接口并分别重写compareTocompare方法来实现，这部分我有些生疏了，故在此写出来后进行回顾。
优先级队列
程序员小木的博客
06-12 413
优先级队列基础知识
优先队列priority_queue中使用pair对的方法
qq_24279775的博客
10-15 8297
优先队列的格式: priority_queuq<type, container, function>; //默认的情况是priority_queue<int, vector<int>, greater<int>>,即大顶堆,排序显示的从小到大. 解决问题:vector<int> nums = {1,2,3,4},vector&lt...
【算法】二叉堆系列，Java优先队列PriorityQueue，滑动窗口及合并k个有序列表的应用
未闻花名丶的博客
04-05 709
二叉堆 通过二叉堆的结构，维护一个小根堆或者大根堆，从而可以很快的找到第k小或者大的元素 PriorityQueue public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable { // 可以定义排序规则，默认是小根堆（越小的元素，越往上） public PriorityQueue(Comparator<? super E>
优先队列放pair,放结构体...sort排结构体，vector，pair... set放结构体
Error Man 的博客
07-02 1422
///vector中的 pair排序 vector&lt;pair&lt;int,char&gt;&gt;V; bool judge(const pair&lt;int,char&gt; a, const pair&lt;int ,char&gt; b) {     return a.first&lt;b.first; /// first 小的在前 } sort(V.b...
蓝桥杯 日志统计 双指针 自定义pair 自定义排序 java
wow_awsl_qwq的博客
12-18 525
import java.util.*; public class Main { static int n,d,k,p,cnt[]=new int [100005]; static pair a[]=new pair[100005]; static boolean b[]=new boolean[100005]; public static void main(String []args) { Scanner sc=new Scanner(System.in); n=sc.nextInt(
pair作为priority_queue元素时，自定义排序算法
硬码农二毛哥的博客
08-07 4490
priority_queue介绍 定义：priority_queue<Type, Container, Functional> Type 就是数据类型。（int ，double等.) Container 就是容器类型（Container必须是用数组实现的容器，默认vector，但不能用 list。） 默认降序排列，push()队尾插入，pop()弹出头元素。 priority_queue<int> a; //降序排列 等同于priority_queue<int,vector&l
priority_queue优先队列的使用方法
gaoqiandr的博客
08-16 4162
说到优先队列，大家肯定想到了队列（这肯定是对于学过队列的同学来说，当然了，没学过也没事，对于本篇文章没什么问题滴），队列的特征是后进后出，按照排队先来后到的顺序的，本篇文章介绍的priority_queue优先队列是按照优先级的顺序来排队，优先级我们可以把它理解成是一种规则，不像队列那样抽象的说是按照时间的，优先队列的这种规则我们可以自己自定义，接下来我们来看看具体的讲解。
【STL】c++优先队列(priority_queue)用法详解
我的笔记本
11-02 906
特性和基本操作 包含头文件：既然是队列那么先要包含头文件#include <queue> 特性：和queue的不同在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面,优先出队 优先队列具有队列的所有特性，包括基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的 和队列基本操作相同: top 访问队头元素 empty 队列是否为空 size 返回队列内元素个数 push 插入元素到队尾 (并排序) emplace 原地构造一个元素并插入队列 pop
priority_queue存放pair，根据pair的first和second排序方法
u014257954的专栏
11-24 8225
比如，按照second来排序，first无所谓。second大的放在最前面：struct cmp{ template<typename T, typename U> bool operator()(T const& left, U const &right) { if (left.second < right.second) return tr
迪杰斯特拉 优先队列
最新发布
09-21
迪杰斯特拉算法是一种用于计算图中一个节点到其他所有节点最短路径的算法，适用于图中所有边权为非负数的情况。优先队列（通常使用最小堆实现）可以有效优化迪杰斯特拉算法的性能。 ### 结合使用方法 迪杰斯特拉算法的每一轮都需要找一个未被访问且距离起点最近的点来进行操作，传统方法需要遍历距离数组，比较耗时。而优先队列以距离排序，队首为距离最小元素。每次更新一个点的距离时，将当前点与距离组合成 `pair` 放入优先队列，每次取出队首，就能知道距离起始点最近的点，大大优化计算时间[^2]。 ### 实现原理 迪杰斯特拉算法从源点出发，不断扩展到其他节点并更新最短路径。使用优先队列时，优先队列用于存储待处理的节点及其到源点的距离。初始时，将源点及其距离（为 0）放入优先队列。每次从优先队列中取出距离源点最近的节点，将其作为当前处理的节点，然后遍历该节点的所有邻接节点，计算通过当前节点到达邻接节点的距离，如果该距离比邻接节点当前记录的距离小，则更新邻接节点的距离，并将邻接节点及其新距离放入优先队列。重复此过程，直到优先队列为空[^1][^2][^4]。 ### 代码实现 #### Python 实现 ```python import heapq def dijkstra(graph, start): distances = {node: float('inf') for node in graph} distances[start] = 0 priority_queue = [(0, start)] while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) if current_distance > distances[current_node]: continue for neighbor, weight in graph[current_node].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue, (distance, neighbor)) return distances # 示例图 graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } start_node = 'A' result = dijkstra(graph, start_node) print(result) ``` #### Java 实现 ```java import java.util.*; class Edge { int source; int destination; int weight; public Edge(int source, int destination, int weight) { this.source = source; this.destination = destination; this.weight = weight; } } class Node implements Comparable<Node> { int node; int distance; public Node(int node, int distance) { this.node = node; this.distance = distance; } @Override public int compareTo(Node other) { return Integer.compare(this.distance, other.distance); } } public class Dijkstra { public static Map<Integer, Integer> dijkstra(Map<Integer, List<Edge>> graph, int start) { Map<Integer, Integer> distances = new HashMap<>(); for (int node : graph.keySet()) { distances.put(node, Integer.MAX_VALUE); } distances.put(start, 0); PriorityQueue<Node> priorityQueue = new PriorityQueue<>(); priorityQueue.add(new Node(start, 0)); while (!priorityQueue.isEmpty()) { Node current = priorityQueue.poll(); int currentNode = current.node; int currentDistance = current.distance; if (currentDistance > distances.get(currentNode)) { continue; } if (graph.containsKey(currentNode)) { for (Edge edge : graph.get(currentNode)) { int neighbor = edge.destination; int weight = edge.weight; int distance = currentDistance + weight; if (distance < distances.get(neighbor)) { distances.put(neighbor, distance); priorityQueue.add(new Node(neighbor, distance)); } } } } return distances; } public static void main(String[] args) { Map<Integer, List<Edge>> graph = new HashMap<>(); // 初始化图 List<Edge> edges1 = new ArrayList<>(); edges1.add(new Edge(0, 1, 1)); edges1.add(new Edge(0, 2, 4)); graph.put(0, edges1); List<Edge> edges2 = new ArrayList<>(); edges2.add(new Edge(1, 0, 1)); edges2.add(new Edge(1, 2, 2)); edges2.add(new Edge(1, 3, 5)); graph.put(1, edges2); List<Edge> edges3 = new ArrayList<>(); edges3.add(new Edge(2, 0, 4)); edges3.add(new Edge(2, 1, 2)); edges3.add(new Edge(2, 3, 1)); graph.put(2, edges3); List<Edge> edges4 = new ArrayList<>(); edges4.add(new Edge(3, 1, 5)); edges4.add(new Edge(3, 2, 1)); graph.put(3, edges4); int startNode = 0; Map<Integer, Integer> result = dijkstra(graph, startNode); System.out.println(result); } } ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值