#include <queue>

双端队列deque比向量vector更有优势

双端队列(deque) 连续存储的指向不同元素的指针所组成的数组<deque>

队列(queue) 先进先出的值的排列 <queue>

优先队列(priority_queue) 元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 <queue>

1 back();

返回向量中的最后一个对象

2 begin();

队列第一个元素位置

3 clear();

删除向量中的所有对象

4 end();

队列最后一个元素的下一个位置

5 erase(iterator it);

删除it所指向的容器对象

6 front();

返回向量中的第1个对象

7 insert(iterator it,const T&);

向it所指的的向量位置前插入一个对象

8 max_size();

返回向量可容纳最多对象的个数

9 pop();

出队列

10 pop_back();

删除向量中最后一个元素

11 pop_front();

删除向量中第一个元素

12 push(const T&);

入队列

13 push_back(const T&);

向向量尾部插入一个对象

14 push_front(const T&);

向向量头部插入一个对象

15 size();

返回当前向量中已经存放的对象的个数

16 swap(deque T&);

交换两个队列的元素

17 top();

取队头元素

使用队列queue，执行命令

 1 #include <iostream>
 2 #include <queue>
 3 
 4 int main()
 5 {
 6     char *p = 0;
 7     std::queue<char *>myq;
 8 
 9     myq.push("calc");//入队列
10     myq.push("notepad");
11     myq.push("tasklist");
12     myq.push("mspaint");
13     
14     while (!myq.empty())
15     {
16         p = myq.front();//返回向量中的第1个对象
17         system(p);
18         myq.pop();//出队列
19     }
20 
21     return 0;
22 }

使用双端队列deque

 1 #include <iostream>
 2 #include <queue>
 3 
 4 int main()
 5 {
 6     std::deque<int>mydq;//双端队列
 7 
 8     mydq.push_back(1);//向向量尾部插入一个对象
 9     mydq.push_back(11);
10     mydq.push_back(111);
11     mydq.push_back(1111);
12     mydq.push_back(11111);
13 
14     mydq.push_front(123);//向向量头部插入一个对象
15 
16     mydq.insert(mydq.begin() + 3, 300);//向it所指的的向量位置前插入一个对象
17 
18     mydq.erase(mydq.end() - 1);//删除it所指向的容器对象，如果要删除最后一个元素，需要end() - 1
19 
20     for (int i = 0; i < mydq.size(); i++)//下标访问
21     {
22         std::cout << mydq[i] << std::endl;
23     }
24     std::cout << std::endl;
25 
26     auto ib = mydq.begin();
27     auto ie = mydq.end();
28 
29     for (; ib != ie; ib++)//迭代器访问
30     {
31         std::cout << *ib << std::endl;
32     }
33     
34     mydq.pop_front();//删除向量中第一个元素
35     mydq.pop_back();//删除向量中最后一个元素
36 
37     mydq.clear();//删除向量中的所有对象
38 
39     return 0;
40 }

交换两个队列的元素

 1 #include <iostream>
 2 #include <queue>
 3 
 4 int main()
 5 {
 6     std::deque<int>mydq1;//双端队列1
 7 
 8     mydq1.push_back(1);//向向量尾部插入一个对象
 9     mydq1.push_back(11);
10     mydq1.push_back(111);
11     mydq1.push_back(1111);
12     mydq1.push_back(11111);
13 
14     std::deque<int>mydq2;//双端队列2
15 
16     mydq2.push_back(2);//向向量尾部插入一个对象
17     mydq2.push_back(21);
18     mydq2.push_back(211);
19     mydq2.push_back(2111);
20     mydq2.push_back(21111);
21 
22     mydq1.swap(mydq2);//交换两个队列的元素
23 
24     {
25         auto ib = mydq1.begin();
26         auto ie = mydq1.end();
27         
28         for (; ib != ie; ib++)//迭代器访问
29         {
30             std::cout << *ib << std::endl;
31         }
32     }
33 
34     std::cout << std::endl;
35 
36     {
37         auto ib = mydq2.begin();
38         auto ie = mydq2.end();
39 
40         for (; ib != ie; ib++)//迭代器访问
41         {
42             std::cout << *ib << std::endl;
43         }
44     }
45     
46     return 0;
47 }

max_size() ;

//返回向量可容纳最多对象的个数

 1 #include <iostream>
 2 #include <queue>
 3 
 4 int main()
 5 {
 6     std::deque<int>mydq;//双端队列
 7 
 8     mydq.push_back(1);//向向量尾部插入一个对象
 9     mydq.push_back(11);
10     mydq.push_back(111);
11     mydq.push_back(1111);
12     mydq.push_back(11111);
13 
14     std::cout << mydq.max_size() << std::endl;//返回向量可容纳最多对象的个数
15 
16     std::cout << mydq.front() << std::endl;//返回向量中的第1个对象
17     std::cout << mydq.back() << std::endl;//返回向量中的最后一个对象
18         
19     return 0;
20 }

优先队列

 1 #include <iostream>
 2 #include <queue>
 3 
 4 int main()
 5 {
 6     std::priority_queue<int>myq;//优先队列
 7 
 8     myq.push(1);
 9     myq.push(12);
10     myq.push(11);
11     myq.push(110);
12     myq.push(101);
13 
14     while (!myq.empty())
15     {
16         std::cout << myq.top() << std::endl;//取队头元素
17         myq.pop();//出队列
18     }
19 
20     return 0;
21 }

优先队列高级用法

 1 #include <iostream>
 2 #include <queue>
 3 #include <string>
 4 #include <vector>
 5 
 6 struct student
 7 {
 8     int age;
 9     std::string name;
10 };
11 
12 struct stuless
13 {
14     bool operator()(const student &s1, const student &s2)
15     {
16         return s1.age < s2.age;
17     }
18 };
19 
20 int main()
21 {
22     std::priority_queue<student, std::vector<student>, stuless>myq;//优先队列高级用法，age为关键字进行排列
23 
24     student s1;
25     s1.age = 10;
26     s1.name = "hello";
27 
28     student s2;
29     s2.age = 9;
30     s2.name = "world";
31 
32     student s3;
33     s3.age = 19;
34     s3.name = "hello world";
35 
36     myq.push(s1);
37     myq.push(s2);
38     myq.push(s3);
39 
40     while (!myq.empty())
41     {
42         std::cout << myq.top().age << " " << myq.top().name << std::endl;
43         myq.pop();
44     }
45 
46     return 0;
47 }