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

    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);
            }
        }
    
    
    }
    
    展开全文
  • c++优先队列自定义排序方式 priqority <node> priq 如何对自定义的数据类型排序? 方法1 struct node { int to,cost; node(int x1,int x2) { to=x1; cost = x2; } friend bool operator<(const no.....

    c++优先队列自定义排序方式

    priqority <node> priq
    如何对自定义的数据类型排序?
    方法1

    struct node
    {
        int to,cost;
        node(int x1,int x2)
        {
            to=x1;
            cost = x2;
        }
        friend bool operator<(const node &a , const node &b)
        {
            return a.cost>b.cost;   // ascending sort
        }
    
    };
    priority_queue<node>priq;
    • 在结构体内定义一个友元函数,重载<号 实现按照cost从小到大排序;
    • 传入两个参数,内部写> 实际上是从小到大排序与sort相反!
      方法2
    struct node
    {
        int to,cost;
        node(int x1,int x2)
        {
            to=x1;
            cost = x2;
        }
    };
    struct cmp
    {
        bool operator() (const node &a,const node &b)
        {
            return a.cost > b.cost;
        }
    };
    priority_queue<node,vector<node>,cmp>priq;

    转载于:https://www.cnblogs.com/star-and-me/p/8681434.html

    展开全文
  • Index:以树的想象理解TRUE的含义 转载于:https://www.cnblogs.com/cyanstable/p/6520345.html

    Index:以树的想象理解TRUE的含义

     

     

     

    转载于:https://www.cnblogs.com/cyanstable/p/6520345.html

    展开全文
  • 一、优先队的使用: 二、基本数据类型: 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...
  • 结构体&优先队列 自定义排序

    千次阅读 2018-05-04 18:29:40
    // 当定义优先队列的时候 这里的 > 代表的是进如有限队列的顺序, // 也就是大的先进,所以出来的顺序是小的先出 } }; // 是被重载的运算符,即如果有两个结构体 a ,b 比较的时候必须是 a如果结果为真,就说明...
  • Cpp实现:#include #include using namespace std;struct Node{int a, b;Node() {}Node(int a, int b) : a(a), b(b) {}bool operator>(const Node& t) const{if (a > t.a) return true;...
  • #include<iostream> #include<vector> #include<queue> using namespace std; int tmp[100]; struct cmp1{ bool operator()(int x,int y) { return x>y;//小的优先级高 ,从小...struct cm...
  • // 当定义优先队列的时候 这里的 > 代表的是进如有限队列的顺序, // 也就是大的先进,所以出来的顺序是小的先出 } }; // 是被重载的运算符,即如果有两个结构体 a ,b 比较的时候必须是 a如果结果为真,就说明...
  • 原文:...简单优先队列的定义方法 //1.默认从大到小排序 priority_queue<int>q; //2.等价于上面(从大到小排序) priority_queue<int,vector<int>,less<int> >q;...
  • 优先队列的使用方法 优先队列的使用方法(自定义排序
  • 优先队列的两种自定义排序方式

    千次阅读 2018-11-16 17:06:23
    首先简单的优先队列的定义方法有三种 1.默认从大到小排序 priority_queue&lt;int&gt;q;...2.等价于上面(从大到小排序) ...3.定义从小到大排序优先队列 priority_queue&lt;int...
  • //定义一个优先队列默认从大到小排序,因为是优先队列呀 如果我们想从小到大排序就需要自定义排序函数了bool operator > ( Node a,Node b) //这里的参数如果是Node* 并不知道为什么 { return a.num > b.nu
  • 自定义优先队列 优先队列内部默认实现的是小根堆,具有的操作主要有: 向队列中添加元素 Queue.put(obj),每添加一个元素优先队列内部就会进行调整成最小堆; 从队列中获取元素 Queue.get(),每取出一个元素队列...
  • 优先队列对pair的自定义排序 #include<iostream> #include<queue> using namespace std; struct cmp{ bool operator() (pair<int,int> a,pair<int,int> b) { return a.second<b.second...
  • C++中优先队列和sort自定义排序算法对比!! 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 269
精华内容 107
关键字:

优先队列自定义排序