精华内容
下载资源
问答
  • C++优先队列自定义排序总结

    千次阅读 2019-11-02 17:13:18
    一、优先队的使用: 二、基本数据类型: 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;
    	}
    };			   	
    
    展开全文
  • 优先队列自定义排序使用方法详解

    千次阅读 2019-04-22 12:38:02
    优先队列: 一般元素类型: 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);
    
    分享:

     

    展开全文
  • 优先队列自定义排序

    2020-07-24 12:26:57
    优先队列 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);
            }
        }
    
    
    }
    
    展开全文
  • 结构体&优先队列 自定义排序

    千次阅读 2018-05-04 18:29:40
    // 当定义优先队列的时候 这里的 > 代表的是进如有限队列的顺序, // 也就是大的先进,所以出来的顺序是小的先出 } }; // 是被重载的运算符,即如果有两个结构体 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(),每取出一个元素队列...
  • 优先队列的两种自定义排序方式

    千次阅读 2018-11-16 17:06:23
    首先简单的优先队列的定义方法有三种 1.默认从大到小排序 priority_queue&lt;int&gt;q;...2.等价于上面(从大到小排序) ...3.定义从小到大排序优先队列 priority_queue&lt;int...
  • python3中自定义排序优先队列

    千次阅读 2019-04-02 17:02:07
    自定义排序的另一种方法以及优先队列如下: 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如果结果为真,就说明...
  • 优先队列的使用方法(自定义排序

    万次阅读 多人点赞 2017-10-02 23:31:49
    参考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++ 优先队列自定义比较函数

    千次阅读 2020-04-07 15:44:31
    C++中的优先队列实质是一种堆(最大堆或最小堆)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,643
精华内容 8,657
关键字:

优先队列自定义排序