1 /*使用标准库的栈*/
  2
  3 #include <stack>    //头文件
  4
  5 stack<int> s;      //定义一个 int 型的栈
  6
  7 s.empty()       //如果栈为空返回true，否则返回false
  8 s.size()           //返回栈中元素的个数
  9 s.pop()           //删除栈顶元素但不返回其值
 10 s.top()            //返回栈顶的元素，但不删除该元素
 11 s.push()          //在栈顶压入新元素
 12
 13
 14
 15 /*使用标准库的队列*/
 16
 17 #include <queue>  //头文件
 18
 19 queue<int> q;      //定义一个 int 型的队列
 20
 21 q.empty()       //如果队列为空返回true，否则返回false
 22 q.size()           //返回队列中元素的个数
 23 q.pop()           //删除队列首元素但不返回其值
 24 q.front()         //返回队首元素的值，但不删除该元素
 25 q.push()          //在队尾压入新元素
 26 q.back()          //返回队列尾元素的值，但不删除该元素
 27
 28
 29
 30 /*优先队列*/
 31
 32
 33 /*优先级队列支持的操作*/
 34
 35 q.empty()          //如果队列为空，则返回true，否则返回false
 36 q.size()              //返回队列中元素的个数
 37 q.pop()              //删除队首元素，但不返回其值
 38 q.top()               //返回具有最高优先级的元素值，但不删除该元素
 39 q.push(item)      //在基于优先级的适当位置插入新元素
 40
 41
 42 /*以下为优先队列的测试代码*/
 43
 44 #include<iostream>
 45 #include<functional>
 46 #include <cstdio>
 47 #include <cstdlib>
 48 #include<queue>
 49 #include<vector>
 50 using namespace std;
 51
 52 //定义比较结构
 53 struct cmp1
 54 {
 55     bool operator ()(int &a,int &b)
 56     {
 57         return a>b;//最小值优先
 58     }
 59 };
 60
 61 struct cmp2
 62 {
 63     bool operator ()(int &a,int &b)
 64     {
 65         return a<b;//最大值优先
 66     }
 67 };
 68
 69 //自定义数据结构
 70 struct number1
 71 {
 72     int x;
 73     bool operator < (const number1 &a) const
 74     {
 75         return x>a.x;//最小值优先
 76     }
 77 };
 78 struct number2
 79 {
 80     int x;
 81     bool operator < (const number2 &a) const
 82     {
 83         return x<a.x;//最大值优先
 84     }
 85 };
 86 int a[]= {14,10,56,7,83,22,36,91,3,47,72,0};
 87 number1 num1[]= {14,10,56,7,83,22,36,91,3,47,72,0};
 88 number2 num2[]= {14,10,56,7,83,22,36,91,3,47,72,0};
 89
 90 int main()
 91 {
 92     priority_queue<int>que;//采用默认优先级构造队列
 93
 94     priority_queue<int,vector<int>,cmp1>que1;//最小值优先
 95     priority_queue<int,vector<int>,cmp2>que2;//最大值优先
 96
 97     priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为错误，在编译器中添加命令：-std=c++11（C++11以后的版本不强制要求添加空格）
 98     priority_queue<int,vector<int>,less<int> >que4;////最大值优先
 99
100     priority_queue<number1>que5; //最小优先级队列
101     priority_queue<number2>que6;  //最大优先级队列
102
103     int i;
104     for(i=0; a[i]; i++)
105     {
106         que.push(a[i]);
107         que1.push(a[i]);
108         que2.push(a[i]);
109         que3.push(a[i]);
110         que4.push(a[i]);
111     }
112     for(i=0; num1[i].x; i++)
113         que5.push(num1[i]);
114     for(i=0; num2[i].x; i++)
115         que6.push(num2[i]);
116
117
118     printf("采用默认优先关系:\n(priority_queue<int>que;)\n");
119     printf("Queue 0:\n");
120     while(!que.empty())
121     {
122         printf("%3d",que.top());
123         que.pop();
124     }
125     puts("");
126     puts("");
127
128     printf("采用结构体自定义优先级方式一:\n(priority_queue<int,vector<int>,cmp>que;)\n");
129     printf("Queue 1:\n");
130     while(!que1.empty())
131     {
132         printf("%3d",que1.top());
133         que1.pop();
134     }
135     puts("");
136     printf("Queue 2:\n");
137     while(!que2.empty())
138     {
139         printf("%3d",que2.top());
140         que2.pop();
141     }
142     puts("");
143     puts("");
144     printf("采用头文件\"functional\"内定义优先级:\n(priority_queue<int,vector<int>,greater<int>/less<int> >que;)\n");
145     printf("Queue 3:\n");
146     while(!que3.empty())
147     {
148         printf("%3d",que3.top());
149         que3.pop();
150     }
151     puts("");
152     printf("Queue 4:\n");
153     while(!que4.empty())
154     {
155         printf("%3d",que4.top());
156         que4.pop();
157     }
158     puts("");
159     puts("");
160     printf("采用结构体自定义优先级方式二:\n(priority_queue<number>que)\n");
161     printf("Queue 5:\n");
162     while(!que5.empty())
163     {
164         printf("%3d",que5.top());
165         que5.pop();
166     }
167     puts("");
168     printf("Queue 6:\n");
169     while(!que6.empty())
170     {
171         printf("%3d",que6.top());
172         que6.pop();
173     }
174     puts("");
175     return 0;
176 }
177 /*
178 运行结果 ：
179 采用默认优先关系:
180 (priority_queue<int>que;)
181 Queue 0:
182 83 72 56 47 36 22 14 10  7  3
183
184 采用结构体自定义优先级方式一:
185 (priority_queue<int,vector<int>,cmp>que;)
186 Queue 1:
187  7 10 14 22 36 47 56 72 83 91
188 Queue 2:
189 83 72 56 47 36 22 14 10  7  3
190
191 采用头文件"functional"内定义优先级:
192 (priority_queue<int,vector<int>,greater<int>/less<int> >que;)
193 Queue 3:
194  7 10 14 22 36 47 56 72 83 91
195 Queue 4:
196 83 72 56 47 36 22 14 10  7  3
197
198 采用结构体自定义优先级方式二:
199 (priority_queue<number>que)
200 Queue 5:
201  7 10 14 22 36 47 56 72 83 91
202 Queue 6:
203 83 72 56 47 36 22 14 10  7  3
204 */