• 一、优先队的使用： 二、基本数据类型： priority_queue<int> q;//默认是从大到小 priority_queue<int, vector<int> ,less<int> >q;//从大到小排序 priority_queue<int, vector<...
一、优先队的使用：
二、基本数据类型：
priority_queue<int> q;//默认是从大到小

priority_queue<int, vector<int> ,less<int> >q;//从大到小排序

priority_queue<int, vector<int>, greater<int> >q;//从小到大排序


三、自定义类型: 第1种：
struct Node
{
char data;
int weight;
Node(char _data, int _weight)
{
data = _data;
weight = _weight;
}
};

(1)weight大的优先级高 :
struct cmp1
{
bool operator () (const Node &a, const Node &b)
{
return a.weight < b.weight;
}
};

构造优先队列：
priority_queue< Node, vector<Node>, cmp1> q1;

(2)weight小的优先级高
struct cmp2
{
bool operator()(const Node &a, const Node &b)
{
return a.weight > b.weight;
}
};

构造优先队列：
priority_queue<Node,vector<Node>,cmp2> q2;

第2种： 重载 < 运算符 (1)weight大的优先
struct Node2
{
char data;
int weight;
Node2(char _data, int _weight)
{
data = _data;
weight = _weight;
}
friend bool operator < (const Node2 &a,const Node2 &b)
{
return a.weight < b.weight;
}
};

构造优先队列：
priority_queue<Node2> q3;

（2)weight小的优先
struct Node3
{
char data;
int weight;
Node3(char _data, int _weight)
{
data = _data;
weight = _weight;
}
friend bool operator < (const Node3 &a,const Node3 &b)
{
return a.weight > b.weight;
}
};

构造优先队列：
priority_queue<Node3> q4;

test代码：
#include<iostream>
#include<vector>
#include<queue>
using namespace std;

struct Node
{
char data;
int weight;
Node(char _data, int _weight)
{
data = _data;
weight = _weight;
}
};
struct cmp1
{

bool operator () (const Node &a, const Node &b)
{
return a.weight < b.weight;			//大的优先级高
}
};
struct cmp2
{
bool operator()(const Node &a, const Node &b)
{
return a.weight > b.weight;			//小的优先级高
}
};
bool cmp(const Node &a,const Node &b)
{
return a.weight > b.weight;
}
struct Node2
{
char data;
int weight;
Node2(char _data, int _weight)
{
data = _data;
weight = _weight;
}
friend bool operator < (const Node2 &a,const Node2 &b)
{
return a.weight < b.weight;
}
};
struct Node3
{
char data;
int weight;
Node3(char _data, int _weight)
{
data = _data;
weight = _weight;
}
friend bool operator < (const Node3 &a,const Node3 &b)
{
return a.weight > b.weight;
}
};
int main()
{
string values = "ABCDEF";
vector<int> weights = {1,2,3,4,5,6};
priority_queue< Node, vector<Node>, cmp1> q1;
for(int i = 0; i < values.length(); i++)
{
Node newNode(values[i],weights[i]);
q1.push(newNode);
}
cout<<"优先队列q1的第一个元素是:  "<<q1.top().data<<endl;

priority_queue<Node,vector<Node>,cmp2> q2;
for(int i = 0; i < values.length(); i++)
{
Node newNode(values[i],weights[i]);
q2.push(newNode);
}
cout<<"优先队列q2的第一个元素是:  "<<q2.top().data<<endl;

priority_queue<Node2> q3;
for(int i = 0; i < values.length(); i++)
{
Node2 newNode(values[i],weights[i]);
q3.push(newNode);
}
cout<<"优先队列q3的第一个元素是:  "<<q3.top().data<<endl;

priority_queue<Node3> q4;
for(int i = 0; i < values.length(); i++)
{
Node3 newNode(values[i],weights[i]);
q4.push(newNode);
}
cout<<"优先队列q4的第一个元素是:  "<<q4.top().data<<endl;
}

运行截图:

更新:
priority_queue< pair<double,int>,
vector<pair<double,int> >,
greater<pair<double,int> > > pq;	//first小的优先
priority_queue< pair<double,int>,
vector<pair<double,int> >,
less<pair<double,int> > > pq;	//first大的优先

first小的优先
class cmp
{
public:
bool operator()(pair<double,int> x, pair<double,int> y)
{
return x.first > y.first;
}
};

first大的优先
class cmp
{
public:
bool operator()(pair<double,int> x, pair<double,int> y)
{
return x.first < y.first;
}
};

展开全文
• 优先队列： 一般元素类型： priosity_queue<int>Q;（默认大顶堆） priosity_queue<int,vector<int>,greater<int>>Q;（小顶堆） 结构体元素类型： struct node { int x,y,z; friend bool...
优先队列：

一般元素类型：
priority_queue<int>Q;（默认大顶堆）
priority_queue<int,vector<int>,greater<int>>Q;（小顶堆）

结构体元素类型：
struct node
{
int x,y,z;
friend bool operator <(const node &a,const node &b)
{
return a.x>b.x;（小顶）
（return a.x<b.x;大顶）
}
};
priority_queue<node>Q;

特殊要求类型：
struct  cmp
{
bool operator ()(const int &a,const int &b)
{
return abs(a-3)>abs(b-3);（小顶）（反之大顶）
}
};
priority_queue<int,vector<int>,cmp>Q;

sort()（默认为升序）:

bool cmp(int a,int b)
{
return a>b;（逆序）
}

struct node
{
int x,y,z;
friend bool operator <(aode a,node b)
{
return a.x<b.x; （升序，反之逆序）
}
}f[100];
sort(f,f+n,cmp);

qsort:
int cmp(const void* a,const void* b)
{
return *(int*)a-*(int*)b;（升序，反之逆序）
}
qsort(f,n,sizeof(f),cmp);

分享：

展开全文
• 优先队列 package com.example.demo; /* peek()//返回队首元素 poll()//返回队首元素，队首元素出队列 add()//添加元素 size()//返回队列元素个数 isEmpty()//判断队列是否为空，为空返回true,不空返回false */ ...
优先队列
package com.example.demo;
/*
peek()//返回队首元素
poll()//返回队首元素，队首元素出队列
add()//添加元素
size()//返回队列元素个数
isEmpty()//判断队列是否为空，为空返回true,不空返回false
*/
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Priority {
int age;
String name;
Priority(int age, String name){
this.age = age;
this.name = name;
}
static Comparator<Integer> cmp = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; //大的在前
}
};
static Comparator<Priority> cmpp = new Comparator<Priority>() {
@Override
public int compare(Priority o1, Priority o2) {
if(o1.age != o2.age) return o1.age - o2.age;
return o1.name.compareTo(o2.name); //字典序从小到大
}
};
public static void main(String[] args) {
// 不使用比较器 按照升序排列 从小到大输出
Queue<Integer> pq = new PriorityQueue<>();
pq.add(3);
pq.add(5);
pq.add(2);
while(!pq.isEmpty()){
System.out.println(pq.poll());
}
// 使用比较器
Queue<Integer> q = new PriorityQueue<>(cmp);
q.add(3);
q.add(5);
q.add(2);
while(!q.isEmpty()){
System.out.println(q.poll());
}
// 自定义排序
Queue<Priority> qq = new PriorityQueue<Priority>(cmpp);
qq.add(new Priority(18,"a"));
qq.add(new Priority(19,"b"));
qq.add(new Priority(12,"c"));
qq.add(new Priority(12,"d"));
Priority priority;
while(!qq.isEmpty()){
priority = qq.poll();
System.out.println(priority.age+" "+priority.name);
}
}

}

展开全文
• // 当定义优先队列的时候 这里的 > 代表的是进如有限队列的顺序， // 也就是大的先进，所以出来的顺序是小的先出 } }; // 是被重载的运算符，即如果有两个结构体 a ,b 比较的时候必须是 a如果结果为真，就说明...
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
struct node
{
LL d;//储存距离
int u;//点的标号
bool operator < ( const node& b)const// & 表示的是引用，
{
return d > b.d; // 当定义优先队列的时候 这里的 > 代表的是进如有限队列的顺序，
//		                  	也就是大的先进，所以出来的顺序是小的先出
}
};
//  < 是被重载的运算符，即如果有两个结构体 a ,b  比较的时候必须是 a<b如果结果为真，就说明 a.d > b.d;如果为假，代表着a.d < b.d 
这篇文章将的很好：https://www.cnblogs.com/Deribs4/p/5657746.html
有空的话看看什么是仿函数；
好像能仿写priority_queue<Node,vertor<Node>,greater(Node)>里面的greator函数
下面是重点摘抄：

2.3 对于自定义类型，则必须重载operator<或者重写仿函数。
2.3.1 重载operator<的例子：返回true时，说明左边形参的优先级低于右边形参
#include <iostream>
#include <queue>
using namespace std;
struct Node{
int x, y;
Node(int a=0, int b=0):
x(a),y(b){}
};
bool operator<(Node a, Node b){//返回true时，说明a的优先级低于b
//x值较大的Node优先级低（x小的Node排在队前）
//x相等时，y大的优先级低（y小的Node排在队前）
if( a.x== b.x ) return a.y> b.y;
return a.x> b.x;
}
int main(){
priority_queue<Node> q;
for( int i= 0; i< 10; ++i )
q.push( Node( rand(), rand() ) );
while( !q.empty() ){
cout << q.top().x << ' ' << q.top().y << endl;
q.pop();
}
return 0;
}
自定义类型重载operator<后，声明对象时就可以只带一个模板参数。
但此时不能像基本类型这样声明priority_queue<Node,vector<Node>,greater<Node> >，原因是greater<Node>没有定义，如果想用这种方法定义则可以重载operator >。
例子：返回的是小顶堆。但不怎么用，习惯是重载operator<。
#include <iostream>
#include <queue>
using namespace std;
struct Node{
int x, y;
Node( int a= 0, int b= 0 ):
x(a), y(b) {}
};
bool operator>( Node a, Node b ){//返回true，a的优先级大于b
//x大的排在队前部；x相同时，y大的排在队前部
if( a.x== b.x ) return a.y> b.y;
return a.x> b.x;
}
int main(){
priority_queue<Node,vector<Node>,greater<Node> > q;
for( int i= 0; i< 10; ++i )
q.push( Node( rand(), rand() ) );
while( !q.empty() ){
cout << q.top().x << ' ' << q.top().y << endl;
q.pop();
}
return 0;
}
2.3.2 重写仿函数的例子（返回值排序与2.3.1相同，都是小顶堆。先按x升序，x相等时，再按y升序）：
#include <iostream>
#include <queue>
using namespace std;
struct Node{
int x, y;
Node( int a= 0, int b= 0 ):
x(a), y(b) {}
};
struct cmp{//重写的仿函数
bool operator() ( Node a, Node b ){//默认是less函数
//返回true时，a的优先级低于b的优先级（a排在b的后面）
if( a.x== b.x ) return a.y> b.y;
return a.x> b.x; }
};
int main(){                        //仿函数替换默认比较方式
priority_queue<Node, vector<Node>, cmp> q;
for( int i= 0; i< 10; ++i )
q.push( Node( rand(), rand() ) );
while( !q.empty() ){
cout << q.top().x << ' ' << q.top().y << endl;
q.pop();
}
return 0;
}

展开全文
• 主要介绍了JAVA使用Comparator接口实现自定义排序，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
• c++优先队列自定义排序方式 priqority <node> priq 如何对自定义的数据类型排序？ 方法1 struct node { int to,cost; node(int x1,int x2) { to=x1; cost = x2; } friend bool operator<(const no.....
• 优先队列自定义排序 优先队列 那么何为优先队列呢，在优先队列中，元素被赋予优先级，当访问元素时，具有最高级优先级的元素先被访问(即优先队列具有最高级先出的行为特征) 优先队列在头文件#include<queue>...
• C++中优先队列和sort自定义排序算法对比！！ 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本...
• 原文：...简单优先队列的定义方法 //1.默认从大到小排序 priority_queue<int>q; //2.等价于上面（从大到小排序） priority_queue<int,vector<int>,less<int> >q;...
• //定义一个优先队列默认从大到小排序，因为是优先队列呀 如果我们想从小到大排序就需要自定义排序函数了bool operator > ( Node a,Node b) //这里的参数如果是Node* 并不知道为什么 { return a.num > b.nu
• 自定义优先队列 优先队列内部默认实现的是小根堆，具有的操作主要有： 向队列中添加元素 Queue.put(obj)，每添加一个元素优先队列内部就会进行调整成最小堆； 从队列中获取元素 Queue.get()，每取出一个元素队列...
• 首先简单的优先队列的定义方法有三种 1.默认从大到小排序 priority_queue&lt;int&gt;q;...2.等价于上面（从大到小排序） ...3.定义从小到大排序优先队列 priority_queue&lt;int...
• 自定义排序的另一种方法以及优先队列如下： from heapq import * class Node: def __init__(self,x,y): self.x=x self.y=y def __lt__(self, other): if self.x==other.x: return self.y else: return ...
• #include<iostream> #include<vector> #include<queue> using namespace std; struct cmp{ bool operator () ( int r , int l ){ return r > l; } ...struct c...
• // 当定义优先队列的时候 这里的 > 代表的是进如有限队列的顺序， // 也就是大的先进，所以出来的顺序是小的先出 } }; // 是被重载的运算符，即如果有两个结构体 a ,b 比较的时候必须是 a如果结果为真，就说明...
• 参考1：... ... 那么何为优先队列呢，在优先队列中，元素被赋予优先级，当访问元素时，具有最高级优先级的元素先被访问。即优先队列具有最高级先出的行为特征。
• Index：以树的想象理解TRUE的含义 转载于:https://www.cnblogs.com/cyanstable/p/6520345.html
• #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;queue&gt; using namespace std; struct cmp{ bool operator () ( int r , int l ){ return r &...struct c...
• 如果要在优先队列中进行结构体排序该怎么办？ 首先定义个结构体A typedef struct A { int l; int r; int label; }a; 接下来就可以定义优先队列，容器中的元素是结构体A #include <queue> priority_...
• Java自带的最优队列，其内部实现方法是一个小顶堆二叉树。最小的节点永远在上方，小顶堆在做前K个这类问题是有比全部排序好的效果。O(Klogn) k<n而整体快排也有O(nlogn)的时间复杂度，所以PriorityQueue是我们...
• C++中的优先队列实质是一种堆（最大堆或最小堆）

...