STL详解（五） 双端队列容器deque
一、deuqe简介
１、deuqe概念
容器deque和vector非常相似，属于序列式容器。都是采用动态数组来管理元素，提供随机存取，并且有着和vector一样的接口。不同的是deque具有首尾两端进行快速插入、删除的能力。
２、Deque结构
如图1是deque的逻辑结构，从表面上看，deque具有连续性的存储空间，并支持随机存取功能。实际上deque并不是我们所看到的样子，其内部结构，如图2所示。
deque在实现上主要有以下两点：
1.由一段一段的定量连续空间构成，第一个区块朝某个方向扩展，最后一个区块朝相反方向扩展；
2.管理这些分段的定量连续空间，维护其整体连续的假象，并提供随机存取的接口；
图 1 deque的逻辑结构
图 2 deque的内部结构
３、Deque的能力
与vector相比，deque功能上的不同之处在于：
- 首尾两端都能快速的安插、删除元素，因此需要在两端安插、删除元素时，最好采用deque。
- 存在元素时，deque的内部结构会多一个间接过程，操作元素的效率会比vector低一些。
- 迭代器需要在不同区块间跳转，所以必须是特殊的智能指针，非一般指针。
- deque不支持对容量和内存重分配时机的控制，除了首尾两端安插、删除元素外，其他地方安插、删除元素都将导致元素的pointer、reference、iterator失效。不过，deque的内存重分配机制优于vector，因为deque不必在内存重分配时复制所有的元素。
- deque的内存区块不再被使用时，会被释放。
- 在建立vector容器时，一般来说伴随这建立空间->填充数据->重建更大空间->复制原空间数据->删除原空间->添加新数据，如此反复，保证vector始终是一块独立的连续内存空间；在建立deque容器时，一般便随着建立空间->建立数据->建立新空间->填充新数据，如此反复，没有原空间数据的复制和删除过程，是由多个连续的内存空间组成的。
使用区别：
1 如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector
2 如果你需要大量的插入和删除，而不关心随即存取，则应使用list
3 如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque
４、deque的操作函数：
Deque的操作函数和vector操作函数基本一模一样，duque的各项操作只有以下几点和vector不同：
１、deque不提供容量操作( capacity()、reserve() )
２、deque提供push_front()、pop_front()函数直接操作头部
５、Deque的特点：
１、支持随机访问，即支持[ ]以及at()，但是性能没有vector好。
２、可以在内部进行插入和删除操作，但性能不及list。
３、deque两端都能够快速插入和删除元素，而vector只能在尾端进行。
４、deque的元素存取和迭代器操作会稍微慢一些，因为deque的内部结构会多一个间接过程。
５、deque迭代器是特殊的智能指针，而不是一般指针，它需要在不同的区块之间跳转。
６、deque可以包含更多的元素，其max_size可能更大，因为不止使用一块内存。
７、deque不支持对容量和内存分配时机的控制。
８、在除了首尾两端的其他地方插入和删除元素，都将会导致指向deque元素的任何pointers、references、iterators失效。不过，deque的内存重分配优于vector，因为其内部结构显示不需要复制所有元素。
９、deque的内存区块不再被使用时，会被释放，deque的内存大小是可缩减的。不过，是不是这么做以及怎么做由实际操作版本定义。
１０、deque不提供容量操作：capacity()和reverse()，但是vector可以。
二、成员函数列表
c.assign(beg,end) 将[beg; end)区间中的数据赋值给c。
c.assign(n,elem) 将n个elem的拷贝赋值给c。
c. at(idx) 传回索引idx所指的数据，如果idx越界，抛出out_of_range。
c.back() 返回容器c的最后一个元素的引用。如果c为空，则该操作未定义。
c.begin() 传回迭代器中的第一个数据地址。
c.clear() 移除容器中所有数据。
c.empty() 判断容器是否为空。
c.end() 返回一个迭代器，它指向容器c的最后一个元素的下一位置。
c.erase(pos) 删除pos位置的数据，传回下一个数据的位置。
c.erase(beg,end) 删除[beg,end)区间的数据，传回下一个数据的位置。
c.front() 返回容器c的第一个元素的引用。如果c为空，则该操作为空。
get_allocator 使用构造函数返回一个拷贝。
c.insert(pos,elem) 在pos位置插入一个elem拷贝，传回新数据位置
c.insert(pos,n,elem) 在pos位置插入>n个elem数据。无返回值
c.insert(pos,beg,end) 在pos位置插入在[beg,end)区间的数据。无返回值
c.max_size() 返回容器c可容纳的最多元素个数。
c.pop_back() 删除最后一个数据。
c.pop_front() 删除头部数据。
c.push_back(elem) 在尾部加入一个数据。
c.push_front(elem) 在头部插入一个数据。
c.rbegin() 返回一个逆序迭代器，它指向容器c的最后一个元素。
c.rend() 返回一个逆序迭代器，它指向容器c的第一个元素的前一个位置。
c.resize(num) 重新指定队列的长度。
c.size() 返回容器中实际数据的个数。
c.swap(c2) 交换容器c和c2中的所有元素。
swap(c1,c2) 交换容器c1和c2中的所有元素，和上一方法相似。
三、成员函数详解
1、构造函数
deque
deque
deque
deque
deque
~deque
２、遍历函数
c.begin()返回指向第一个元素的迭代器
c.end()返回指向最后一个元素下一个位置的迭代器
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
deque::iterator it;
for(it=d.begin();it!=d.end();it++){
cout << *it << " ";
}
cout << endl;
} 运行结果： １ ２ ３ ４ ５
c.rbegin()返回指向反向队列的第一个元素的迭代器(即原队列的最后一个元素)
c.rend()返回指向反向队列的最后一个元素的下一个位置(即原队列的第一个元素的前一个位置)
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
deque::reverse_iterator it;
for(it=d.rbegin();it!=d.rend();it++)
cout << *it << " ";
cout << endl;
} 运行结果： ５ ４ ３ ２ １
c.at(pos)返回索引为pos的位置的元素,会执行边界检查,如果越界抛出out_of_range异常
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
cout << "d.at(pos):" << d.at(4);
return 0;
} 运行结果： d.at(pos): 5
c.operator[ ]下标运算符重载
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
cout << "d[2]:" << d[2];
return 0;
} 运行结果： d.[2]: 3
c.front()返回c容器的第一个元素
c.back()返回c容器的最后一个元素
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
if(!d.empty())
{ cout << "d.front():" << d.front() << endl;
cout << "d.back(): " << d.back() << endl;
}
} 运行结果：
d.front():1
d.back():5
３、修改函数（增加，删除，交换，赋值等）
c.assign(n,num)将n个num拷贝复制到容器c
c.assign(beg,end)将[beg,end)区间的数据拷贝复制到容器c
#include
using namespace std;
int main()
{ deque d1 ,d2;
for (int i = 1; i <= 5; i++) d1.push_back(i);
d2.assign(2, 8);
deque::iterator it;
cout << "d2.assign(n,num):";
for(it=d2.begin();it!=d2.end();it++)
cout << *it << " ";
cout< 运行结果：
d2.assign(n,num): 8 8
d2.assign(beg,end): 1 2 3
operator=赋值运算符重载
#include
using namespace std;
int main()
{ deque d1,d2;
for (int i = 1; i <= 5; i++) d1.push_back(i);
d2 = d1;
deque::iterator it;
for(it=d2.begin();it!=d2.end();it++)
cout << *it << " ";
cout << endl;
} 运行结果： １ ２ ３ ４ ５
c.insert(pos,num)在pos位置插入元素num
c.insert(pos,n,num)在pos位置插入n个元素num
c.insert(pos,beg,end)在pos位置插入区间为[beg,end)的元素
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
deque::iterator it;
cout << "insert before:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
d.insert(d.end(),22);
d.insert(d.end(), 3,88);
int a[5] = {1,2,3,4,5};
d.insert(d.begin(),a,a+3);
cout << "insert after:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
} 运行结果：
insert before:1 2 3 4 5
insert after:1 2 3 1 2 3 4 5 22 88 88 88
c.push_back(num)在末尾位置插入元素
c.pop_back()删除末尾位置的元素
c.push_front(num)在开头位置插入元素
c.pop_front()删除开头位置的元素
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
d.push_back(10);
deque::iterator it;
cout << "push_back(num):" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
d.pop_back();
cout << "pop_back(num):" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
d.push_front(10);
cout << "push_front(num):" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
d.pop_front();
cout << "pop_front(num):" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
return 0;
} 运行结果：
push_back(num):1 2 3 4 5 10
pop_back(num):1 2 3 4 5
push_front(num):10 1 2 3 4 5
pop_front(num):1 2 3 4 5
c.erase(pos)删除pos位置的元素c.erase(beg,end)删除区间为[beg,end)的元素
c.erase(beg,end)删除区间为[beg,end)之间的元素
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
d.erase(d.begin());
deque::iterator it;
cout << "erase(pos) after:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
d.erase(d.begin(), d.begin()+3);
cout << "erase(beg,end) after:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
} 运行结果：
erase(pos) after:2 3 4 5
erase(beg,end) after:5
c.clear()清除c容器中拥有的所有元素
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
deque::iterator it;
cout << "clear before:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
cout << endl;
d.clear();
cout << "clear after:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
} 运行结果：
clear before:1 2 3 4 5
clear after:
c1.swap(c2)交换容器c1,c2;
swap(c1,c2)同上。
#include
using namespace std;
int main()
{ deque d1,d2,d3;
for (int i = 1; i <= 5; i++) d1.push_back(i);
d1.swap(d2);
deque::iterator it;
cout << "d1 swap after:" ;
for(it=d1.begin();it!=d1.end();it++)
cout << *it << " ";
cout << endl;
cout << "d2 swap after:" ;
for(it=d2.begin();it!=d2.end();it++)
cout << *it << " ";
cout << endl;
swap(d3,d2);
cout << "d3 swap after:" ;
for(it=d3.begin();it!=d3.end();it++)
cout << *it << " ";
cout << endl;
} 运行结果：
d1 swap after:
d2 swap after:1 2 3 4 5
d3 swap after:1 2 3 4 5
４、判断函数及其它
c.empty()判断c容器是否为空
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
if(!d.empty())
cout << "d is not empty!" << endl;
else
cout << "d is empty!" << endl;
return 0;
} 运行结果： d is not empty!
c.size()返回c容器中实际拥有的元素个数
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
cout << "d.size():" << d.size() << endl;
return 0;
} 运行结果：d.size():5
c.resize(num)从新定义容器的大小
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
cout << "d.size():" << d.size() << endl;
d.resize(d.size()+5);
cout << "d.resize() after:" << d.size() <::iterator it;
cout << "resize() after:" ;
for(it=d.begin();it!=d.end();it++)
cout << *it << " ";
} 运行结果：
d.size():5
d.resize() after:10
resize() after:1 2 3 4 5 0 0 0 0 0
c.max_size()返回c容器可能存放元素的最大数量
#include
using namespace std;
int main()
{ deque d ;
for (int i = 1; i <= 5; i++) d.push_back(i);
cout << "d.max_size():" << d.max_size() << endl;
return 0;
} 运行结果：d.max_size():1073741823
重载运算符
operator==
operator!=
operator<
operator<=
operator>
operator>=
练习：
读程序写结果：
第一题：
#include
using namespace std;
int main()
{ deque d;
d.push_back( 10 );
d.push_back(20);
d.push_back(30);
cout<<"原始双端队列："< 第二题：
#include
using namespace std;
int main()
{ deque ideq(20);
deque::iterator pos;
int i;
//使用assign()赋值 assign在计算机中就是赋值的意思
for (i = 0; i < 20; ++i)
ideq[i] = i;
printf("输出deque中数据:\n");
for (i = 0; i < 20; ++i)
printf("%d ", ideq[i]);
putchar('\n');
printf("\n在头尾加入新数据...\n");
ideq.push_back(100);
ideq.push_front(i);
printf("\n输出deque中数据:\n");
for (pos = ideq.begin(); pos != ideq.end(); pos++)
printf("%d ", *pos);
putchar('\n');
const int FINDNUMBER = 19;
printf("\n查找%d\n", FINDNUMBER);
pos = find(ideq.begin(), ideq.end(), FINDNUMBER);
if (pos != ideq.end())
printf("find %d success\n", *pos);
else
printf("find failed\n");
printf("\n在头尾删除数据...\n");
ideq.pop_back();
ideq.pop_front();
printf("\n输出deque中数据:\n");
for (pos = ideq.begin(); pos != ideq.end(); pos++)
printf("%d ", *pos);
putchar('\n');
return 0;
}