STL 优先队列的优先级

转载于http://blog.csdn.net/a_eagle/article/details/7371974

 1 <span style="font-size:24px;">struct cmp1  
 2 {    
 3     bool operator ()(int &a,int &b)  
 4     {    
 5         return a>b;//最小值优先     
 6     }    
 7 };    
 8 struct cmp2  
 9 {    
10     bool operator ()(int &a,int &b)  
11     {    
12         return a<b;//最大值优先     
13     }    
14 };    
15 struct node1  
16 {    
17     int u;    
18     bool operator < (const node1 &a) const   
19     {    
20        return u>a.u;//最小值优先     
21     }    
22 };    
23 struct node2  
24 {    
25     int u;    
26     bool operator < (const node2 &a) const   
27     {    
28         return u<a.u;//最大值优先     
29     }    
30 };   
31 priority_queue<int>q1;//采用默认优先级构造队列       
32 priority_queue<int,vector<int>,cmp1>q2;//最小值优先     
33 priority_queue<int,vector<int>,cmp2>q3;//最大值优先     
34 priority_queue<int,vector<int>,greater<int> >q4;//注意“>>”会被认为错误,     
35                                                 //这是右移运算符,所以这里用空格号隔开,最小值优先   
36 priority_queue<int,vector<int>,less<int> >q5;//最大值优先      
37 priority_queue<node1>q6;  //自定义优先级  
38 priority_queue<node2>q7;</span>  

STL 中优先队列的使用方法(priority_queu)

基本操作:

empty() 如果队列为空返回真

pop() 删除对顶元素

push() 加入一个元素

size() 返回优先队列中拥有的元素个数

top() 返回优先队列对顶元素

在默认的优先队列中,优先级高的先出队。在默认的int型中先出队的为较大的数。

使用方法:

头文件:

#include <queue>

声明方式:

1、普通方法:

priority_queue<int>q; //通过操作,按照元素从大到小的顺序出队

2、自定义优先级:

 1 [cpp] view plain copy
 2 struct cmp  
 3 {  
 4     operator bool ()(int x, int y)  
 5     {  
 6         return x > y; // x小的优先级高  
 7       //也可以写成其他方式,如: return p[x] > p[y];表示p[i]小的优先级高  
 8 }  
 9 };  
10 priority_queue<int, vector<int>, cmp>q;//定义方法  
11 
12 [cpp] view plain copy
13 //其中,第二个参数为容器类型。第三个参数为比较函数。  

3、结构体声明方式:

 1 [cpp] view plain copy
 2 struct node  
 3 {  
 4     int x, y;  
 5     friend bool operator < (node a, node b)  
 6     {  
 7         return a.x > b.x; //结构体中,x小的优先级高  
 8     }  
 9 };  
10 <span style="font-size:24px;">priority_queue<node>q;//定义方法</span>
/在该结构中,y为值, x为优先级。 //通过自定义operator<操作符来比较元素中的优先级。 //在重载”<”时,最好不要重载”>”,可能会发生编译错误

STL 中队列的使用(queue)

基本操作:

push(x) 将x压入队列的末端

pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值

front() 返回第一个元素(队顶元素)

back() 返回最后被压入的元素(队尾元素)

empty() 当队列为空时,返回true

size() 返回队列的长度

 

使用方法:

头文件:

#include <queue>

 声明方法:

1、普通声明

queue<int>q;

2、结构体

struct node {     int x, y; }; queue<node>q;

STL 中栈的使用方法(stack)

基本操作:

push(x) 将x加入栈中,即入栈操作

pop() 出栈操作(删除栈顶),只是出栈,没有返回值

top() 返回第一个元素(栈顶元素)

size() 返回栈中的元素个数

empty() 当栈为空时,返回 true

使用方法:

和队列差不多,其中头文件为:

#include <stack>

定义方法为:

stack<int>s1;//入栈元素为 int 型 stack<string>s2;// 入队元素为string型 stack<node>s3;//入队元素为自定义型
 1 [cpp] view plain copy
 2 /**//* 
 3 *===================================* 
 4 |                                   | 
 5 |       STL中优先队列使用方法       | 
 6 |                                   |         
 7 |       chenlie                     | 
 8 |                                   | 
 9 |       2010-3-24                   | 
10 |                                   | 
11 *===================================* 
12 */  
13 #include <iostream>  
14 #include <vector>  
15 #include <queue>  
16 using namespace std;  
17 int c[100];  
18   
19 struct cmp1  
20 {  
21      bool operator ()(int x, int y)  
22     {  
23         return x > y;//小的优先级高  
24     }  
25 };  
26   
27 struct cmp2  
28 {  
29     bool operator ()(const int x, const int y)  
30     {  
31         return c[x] > c[y];   
32        // c[x]小的优先级高,由于可以在对外改变队内的值,  
33         //所以使用此方法达不到真正的优先。建议用结构体类型。  
34     }  
35 };  
36   
37 struct node  
38 {  
39     int x, y;  
40     friend bool operator < (node a, node b)  
41     {  
42         return a.x > b.x;//结构体中,x小的优先级高  
43     }  
44 };  
45   
46   
47 priority_queue<int>q1;  
48   
49 priority_queue<int, vector<int>, cmp1>q2;  
50   
51 priority_queue<int, vector<int>, cmp2>q3;  
52   
53 priority_queue<node>q4;  
54   
55   
56 queue<int>qq1;  
57 queue<node>qq2;  
58   
59 int main()  
60 {  
61     int i, j, k, m, n;  
62     int x, y;  
63     node a;  
64     while (cin >> n)  
65     {  
66         for (i = 0; i < n; i++)  
67         {  
68             cin >> a.y >> a.x;  
69             q4.push(a);  
70         }  
71         cout << endl;  
72         while (!q4.empty())  
73         {  
74             cout << q4.top().y << " " << q4.top().x << endl;  
75             q4.pop();  
76         }  
77     //    cout << endl;  
78     }  
79     return 0;  
80 }  
 1 [cpp] view plain copy
 2 #include<stdio.h>  
 3 #include<queue>  
 4 #include<algorithm>  
 5 using namespace std;  
 6 struct comp  
 7 {  
 8     bool operator()(int &x,int &y)  
 9     {  
10         return x<y;  
11     }  
12 };  
13 priority_queue<int,vector<int>,comp>q;/*优先队列*/  
14 int main()  
15 {  
16     q.push(2);  
17     q.push(1);  
18     q.push(3);  
19     while(!q.empty())  
20     {  
21         printf("%d ",q.top());  
22         q.pop();  
23     }  
24     printf("\n");  
25     return 0;  
26 }  

 

转载于http://blog.csdn.net/a_eagle/article/details/7371974

 1 <span style="font-size:24px;">struct cmp1  
 2 {    
 3     bool operator ()(int &a,int &b)  
 4     {    
 5         return a>b;//最小值优先     
 6     }    
 7 };    
 8 struct cmp2  
 9 {    
10     bool operator ()(int &a,int &b)  
11     {    
12         return a<b;//最大值优先     
13     }    
14 };    
15 struct node1  
16 {    
17     int u;    
18     bool operator < (const node1 &a) const   
19     {    
20        return u>a.u;//最小值优先     
21     }    
22 };    
23 struct node2  
24 {    
25     int u;    
26     bool operator < (const node2 &a) const   
27     {    
28         return u<a.u;//最大值优先     
29     }    
30 };   
31 priority_queue<int>q1;//采用默认优先级构造队列       
32 priority_queue<int,vector<int>,cmp1>q2;//最小值优先     
33 priority_queue<int,vector<int>,cmp2>q3;//最大值优先     
34 priority_queue<int,vector<int>,greater<int> >q4;//注意“>>”会被认为错误,     
35                                                 //这是右移运算符,所以这里用空格号隔开,最小值优先   
36 priority_queue<int,vector<int>,less<int> >q5;//最大值优先      
37 priority_queue<node1>q6;  //自定义优先级  
38 priority_queue<node2>q7;</span>  

STL 中优先队列的使用方法(priority_queu)

基本操作:

empty() 如果队列为空返回真

pop() 删除对顶元素

push() 加入一个元素

size() 返回优先队列中拥有的元素个数

top() 返回优先队列对顶元素

在默认的优先队列中,优先级高的先出队。在默认的int型中先出队的为较大的数。

使用方法:

头文件:

#include <queue>

声明方式:

1、普通方法:

priority_queue<int>q; //通过操作,按照元素从大到小的顺序出队

2、自定义优先级:

 1 [cpp] view plain copy
 2 struct cmp  
 3 {  
 4     operator bool ()(int x, int y)  
 5     {  
 6         return x > y; // x小的优先级高  
 7       //也可以写成其他方式,如: return p[x] > p[y];表示p[i]小的优先级高  
 8 }  
 9 };  
10 priority_queue<int, vector<int>, cmp>q;//定义方法  
11 
12 [cpp] view plain copy
13 //其中,第二个参数为容器类型。第三个参数为比较函数。  

3、结构体声明方式:

 1 [cpp] view plain copy
 2 struct node  
 3 {  
 4     int x, y;  
 5     friend bool operator < (node a, node b)  
 6     {  
 7         return a.x > b.x; //结构体中,x小的优先级高  
 8     }  
 9 };  
10 <span style="font-size:24px;">priority_queue<node>q;//定义方法</span>
/在该结构中,y为值, x为优先级。 //通过自定义operator<操作符来比较元素中的优先级。 //在重载”<”时,最好不要重载”>”,可能会发生编译错误

STL 中队列的使用(queue)

基本操作:

push(x) 将x压入队列的末端

pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值

front() 返回第一个元素(队顶元素)

back() 返回最后被压入的元素(队尾元素)

empty() 当队列为空时,返回true

size() 返回队列的长度

 

使用方法:

头文件:

#include <queue>

 声明方法:

1、普通声明

queue<int>q;

2、结构体

struct node {     int x, y; }; queue<node>q;

STL 中栈的使用方法(stack)

基本操作:

push(x) 将x加入栈中,即入栈操作

pop() 出栈操作(删除栈顶),只是出栈,没有返回值

top() 返回第一个元素(栈顶元素)

size() 返回栈中的元素个数

empty() 当栈为空时,返回 true

使用方法:

和队列差不多,其中头文件为:

#include <stack>

定义方法为:

stack<int>s1;//入栈元素为 int 型 stack<string>s2;// 入队元素为string型 stack<node>s3;//入队元素为自定义型
 1 [cpp] view plain copy
 2 /**//* 
 3 *===================================* 
 4 |                                   | 
 5 |       STL中优先队列使用方法       | 
 6 |                                   |         
 7 |       chenlie                     | 
 8 |                                   | 
 9 |       2010-3-24                   | 
10 |                                   | 
11 *===================================* 
12 */  
13 #include <iostream>  
14 #include <vector>  
15 #include <queue>  
16 using namespace std;  
17 int c[100];  
18   
19 struct cmp1  
20 {  
21      bool operator ()(int x, int y)  
22     {  
23         return x > y;//小的优先级高  
24     }  
25 };  
26   
27 struct cmp2  
28 {  
29     bool operator ()(const int x, const int y)  
30     {  
31         return c[x] > c[y];   
32        // c[x]小的优先级高,由于可以在对外改变队内的值,  
33         //所以使用此方法达不到真正的优先。建议用结构体类型。  
34     }  
35 };  
36   
37 struct node  
38 {  
39     int x, y;  
40     friend bool operator < (node a, node b)  
41     {  
42         return a.x > b.x;//结构体中,x小的优先级高  
43     }  
44 };  
45   
46   
47 priority_queue<int>q1;  
48   
49 priority_queue<int, vector<int>, cmp1>q2;  
50   
51 priority_queue<int, vector<int>, cmp2>q3;  
52   
53 priority_queue<node>q4;  
54   
55   
56 queue<int>qq1;  
57 queue<node>qq2;  
58   
59 int main()  
60 {  
61     int i, j, k, m, n;  
62     int x, y;  
63     node a;  
64     while (cin >> n)  
65     {  
66         for (i = 0; i < n; i++)  
67         {  
68             cin >> a.y >> a.x;  
69             q4.push(a);  
70         }  
71         cout << endl;  
72         while (!q4.empty())  
73         {  
74             cout << q4.top().y << " " << q4.top().x << endl;  
75             q4.pop();  
76         }  
77     //    cout << endl;  
78     }  
79     return 0;  
80 }  
 1 [cpp] view plain copy
 2 #include<stdio.h>  
 3 #include<queue>  
 4 #include<algorithm>  
 5 using namespace std;  
 6 struct comp  
 7 {  
 8     bool operator()(int &x,int &y)  
 9     {  
10         return x<y;  
11     }  
12 };  
13 priority_queue<int,vector<int>,comp>q;/*优先队列*/  
14 int main()  
15 {  
16     q.push(2);  
17     q.push(1);  
18     q.push(3);  
19     while(!q.empty())  
20     {  
21         printf("%d ",q.top());  
22         q.pop();  
23     }  
24     printf("\n");  
25     return 0;  
26 }  

 

转载于http://blog.csdn.net/a_eagle/article/details/7371974

 1 <span style="font-size:24px;">struct cmp1  
 2 {    
 3     bool operator ()(int &a,int &b)  
 4     {    
 5         return a>b;//最小值优先     
 6     }    
 7 };    
 8 struct cmp2  
 9 {    
10     bool operator ()(int &a,int &b)  
11     {    
12         return a<b;//最大值优先     
13     }    
14 };    
15 struct node1  
16 {    
17     int u;    
18     bool operator < (const node1 &a) const   
19     {    
20        return u>a.u;//最小值优先     
21     }    
22 };    
23 struct node2  
24 {    
25     int u;    
26     bool operator < (const node2 &a) const   
27     {    
28         return u<a.u;//最大值优先     
29     }    
30 };   
31 priority_queue<int>q1;//采用默认优先级构造队列       
32 priority_queue<int,vector<int>,cmp1>q2;//最小值优先     
33 priority_queue<int,vector<int>,cmp2>q3;//最大值优先     
34 priority_queue<int,vector<int>,greater<int> >q4;//注意“>>”会被认为错误,     
35                                                 //这是右移运算符,所以这里用空格号隔开,最小值优先   
36 priority_queue<int,vector<int>,less<int> >q5;//最大值优先      
37 priority_queue<node1>q6;  //自定义优先级  
38 priority_queue<node2>q7;</span>  

STL 中优先队列的使用方法(priority_queu)

基本操作:

empty() 如果队列为空返回真

pop() 删除对顶元素

push() 加入一个元素

size() 返回优先队列中拥有的元素个数

top() 返回优先队列对顶元素

在默认的优先队列中,优先级高的先出队。在默认的int型中先出队的为较大的数。

使用方法:

头文件:

#include <queue>

声明方式:

1、普通方法:

priority_queue<int>q; //通过操作,按照元素从大到小的顺序出队

2、自定义优先级:

 1 [cpp] view plain copy
 2 struct cmp  
 3 {  
 4     operator bool ()(int x, int y)  
 5     {  
 6         return x > y; // x小的优先级高  
 7       //也可以写成其他方式,如: return p[x] > p[y];表示p[i]小的优先级高  
 8 }  
 9 };  
10 priority_queue<int, vector<int>, cmp>q;//定义方法  
11 
12 [cpp] view plain copy
13 //其中,第二个参数为容器类型。第三个参数为比较函数。  

3、结构体声明方式:

 1 [cpp] view plain copy
 2 struct node  
 3 {  
 4     int x, y;  
 5     friend bool operator < (node a, node b)  
 6     {  
 7         return a.x > b.x; //结构体中,x小的优先级高  
 8     }  
 9 };  
10 <span style="font-size:24px;">priority_queue<node>q;//定义方法</span>
/在该结构中,y为值, x为优先级。 //通过自定义operator<操作符来比较元素中的优先级。 //在重载”<”时,最好不要重载”>”,可能会发生编译错误

STL 中队列的使用(queue)

基本操作:

push(x) 将x压入队列的末端

pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值

front() 返回第一个元素(队顶元素)

back() 返回最后被压入的元素(队尾元素)

empty() 当队列为空时,返回true

size() 返回队列的长度

 

使用方法:

头文件:

#include <queue>

 声明方法:

1、普通声明

queue<int>q;

2、结构体

struct node {     int x, y; }; queue<node>q;

STL 中栈的使用方法(stack)

基本操作:

push(x) 将x加入栈中,即入栈操作

pop() 出栈操作(删除栈顶),只是出栈,没有返回值

top() 返回第一个元素(栈顶元素)

size() 返回栈中的元素个数

empty() 当栈为空时,返回 true

使用方法:

和队列差不多,其中头文件为:

#include <stack>

定义方法为:

stack<int>s1;//入栈元素为 int 型 stack<string>s2;// 入队元素为string型 stack<node>s3;//入队元素为自定义型
 1 [cpp] view plain copy
 2 /**//* 
 3 *===================================* 
 4 |                                   | 
 5 |       STL中优先队列使用方法       | 
 6 |                                   |         
 7 |       chenlie                     | 
 8 |                                   | 
 9 |       2010-3-24                   | 
10 |                                   | 
11 *===================================* 
12 */  
13 #include <iostream>  
14 #include <vector>  
15 #include <queue>  
16 using namespace std;  
17 int c[100];  
18   
19 struct cmp1  
20 {  
21      bool operator ()(int x, int y)  
22     {  
23         return x > y;//小的优先级高  
24     }  
25 };  
26   
27 struct cmp2  
28 {  
29     bool operator ()(const int x, const int y)  
30     {  
31         return c[x] > c[y];   
32        // c[x]小的优先级高,由于可以在对外改变队内的值,  
33         //所以使用此方法达不到真正的优先。建议用结构体类型。  
34     }  
35 };  
36   
37 struct node  
38 {  
39     int x, y;  
40     friend bool operator < (node a, node b)  
41     {  
42         return a.x > b.x;//结构体中,x小的优先级高  
43     }  
44 };  
45   
46   
47 priority_queue<int>q1;  
48   
49 priority_queue<int, vector<int>, cmp1>q2;  
50   
51 priority_queue<int, vector<int>, cmp2>q3;  
52   
53 priority_queue<node>q4;  
54   
55   
56 queue<int>qq1;  
57 queue<node>qq2;  
58   
59 int main()  
60 {  
61     int i, j, k, m, n;  
62     int x, y;  
63     node a;  
64     while (cin >> n)  
65     {  
66         for (i = 0; i < n; i++)  
67         {  
68             cin >> a.y >> a.x;  
69             q4.push(a);  
70         }  
71         cout << endl;  
72         while (!q4.empty())  
73         {  
74             cout << q4.top().y << " " << q4.top().x << endl;  
75             q4.pop();  
76         }  
77     //    cout << endl;  
78     }  
79     return 0;  
80 }  
 1 [cpp] view plain copy
 2 #include<stdio.h>  
 3 #include<queue>  
 4 #include<algorithm>  
 5 using namespace std;  
 6 struct comp  
 7 {  
 8     bool operator()(int &x,int &y)  
 9     {  
10         return x<y;  
11     }  
12 };  
13 priority_queue<int,vector<int>,comp>q;/*优先队列*/  
14 int main()  
15 {  
16     q.push(2);  
17     q.push(1);  
18     q.push(3);  
19     while(!q.empty())  
20     {  
21         printf("%d ",q.top());  
22         q.pop();  
23     }  
24     printf("\n");  
25     return 0;  
26 }  

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值