C++ deques

deque双向队列是一种双向开口的连续线性空间，可以高效的在头尾两端插入和删除元素
ms-help://MS.MSDNQTR.v90.chs/dv_vcstdlib/html/64842ee5-057a-4063-8c16-4267a0332584.htm
Constructors 构造函数   
assign() 元素赋值   
at() 返回指定位置的元素   
back() 返回最末一个元素   
begin() 返回第一个元素的迭代器   
capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下）   
clear() 清空所有元素   
empty() 判断是否为空（返回true时为空）   
end() 返回最末元素的迭代器(译注:实指向最末元素的下一个位置)   
erase() 删除指定元素   
front() 返回第一个元素   
get_allocator() 返回的内存分配器   
insert() 插入元素到中   
max_size() 返回所能容纳元素的最大数量（上限）   
pop_back() 移除最后一个元素   
push_back() 在最后添加一个元素   
push_front()将一个元素添加到双端队列的开头
rbegin() 返回尾部的逆迭代器   
rend() 返回起始的逆迭代器   
reserve() 设置最小的元素容纳数量   
resize() 改变元素数量的大小   
size() 返回元素数量的大小   
swap() 交换   

#include <deque>
#include <iostream>

//构造函数
void DequeConstructor(void);

//元素赋值 
void Deque_assign(void);

//返回指定位置的元素
void Deque_at(void);

//返回最末一个元素 
void Deque_back(void);

//返回第一个元素的迭代器 
void Deque_begin(void);

//清空所有元素
void Deque_clear(void);

//判断是否为空（返回true时为空）
void Deque_empty(void);

//返回最末元素的迭代器(译注:实指向最末元素的下一个位置)
void Deque_end(void);

//删除指定元素 
void Deque_erase(void);

//返回第一个元素
void Deque_front(void);

//返回内存分配器 
void Deque_get_allocator(void);

//插入元素到
void Deque_insert(void);

//返回所能容纳元素的最大数量（上限）
void Deque_max_size(void);

//移除最后一个元素
void Deque_pop_back(void);

//在最后添加一个元素
void Deque_push_back(void);

//将一个元素添加到双端队列的开头
void Deque_push_front(void);

//返回尾部的逆迭代器
void Deque_rbegin(void);

//返回起始的逆迭代器
void Deque_rend(void);

//改变元素数量的大小
void Deque_resize(void);

//返回元素数量的大小
void Deque_size(void);

//交换
void Deque_swap(void);

int main()
{
	//DequeConstructor();
	//Deque_assign();
	//Deque_at();
	//Deque_back();
	//Deque_begin();
	//Deque_clear();
	//Deque_empty();
	//Deque_end();
	//Deque_erase();
	//Deque_front();
	//Deque_get_allocator();
	//Deque_insert();
	//Deque_max_size();
	//Deque_pop_back();
	//Deque_push_back();
	//Deque_push_front();
	//Deque_rbegin();
	//Deque_rend();
	//Deque_resize();
	//Deque_size();
	Deque_swap();
	return 0;
}

//构造函数
void DequeConstructor(void)
{
	using namespace std;
	deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

	// Create an empty deque c0
	deque <int> c0;

	// Create a deque c1 with 3 elements of default value 0
	deque <int> c1(3);

	// Create a deque c2 with 5 elements of value 2
	deque <int> c2(5, 2);

	// Create a deque c3 with 3 elements of value 1 and with the 
	// allocator of deque c2
	deque <int> c3(3, 1, c2.get_allocator());

	// Create a copy, deque c4, of deque c2
	deque <int> c4(c2);

	// Create a deque c5 by copying the range c4[_First, _Last)
	c4_Iter = c4.begin();
	c4_Iter++;
	c4_Iter++;
	deque <int> c5(c4.begin(), c4_Iter);

	// Create a deque c6 by copying the range c4[_First, _Last) and 
	// c2 with the allocator of deque
	c4_Iter = c4.begin();
	c4_Iter++;
	c4_Iter++;
	c4_Iter++;
	deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

	cout << "c1 = ";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << *c1_Iter << " ";
	cout << endl;

	cout << "c2 = ";
	for (c2_Iter = c2.begin(); c2_Iter != c2.end(); c2_Iter++)
		cout << *c2_Iter << " ";
	cout << endl;

	cout << "c3 = ";
	for (c3_Iter = c3.begin(); c3_Iter != c3.end(); c3_Iter++)
		cout << *c3_Iter << " ";
	cout << endl;

	cout << "c4 = ";
	for (c4_Iter = c4.begin(); c4_Iter != c4.end(); c4_Iter++)
		cout << *c4_Iter << " ";
	cout << endl;

	cout << "c5 = ";
	for (c5_Iter = c5.begin(); c5_Iter != c5.end(); c5_Iter++)
		cout << *c5_Iter << " ";
	cout << endl;

	cout << "c6 = ";
	for (c6_Iter = c6.begin(); c6_Iter != c6.end(); c6_Iter++)
		cout << *c6_Iter << " ";
	cout << endl;
	return;
	/*
	c1 = 0 0 0
	c2 = 2 2 2 2 2
	c3 = 1 1 1
	c4 = 2 2 2 2 2
	c5 = 2 2
	c6 = 2 2 2
	请按任意键继续. . .
	*/
}

//元素赋值 
void Deque_assign(void)
{
	using namespace std;
	deque <int> c1, c2;
	deque <int>::const_iterator cIter;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);
	c2.push_back(40);
	c2.push_back(50);
	c2.push_back(60);

	cout << "c1 =";
	for (cIter = c1.begin(); cIter != c1.end(); cIter++)
		cout << " " << *cIter;
	cout << endl;

	c1.assign(++c2.begin(), c2.end());
	cout << "c1 =";
	for (cIter = c1.begin(); cIter != c1.end(); cIter++)
		cout << " " << *cIter;
	cout << endl;

	c1.assign(7, 4);
	cout << "c1 =";
	for (cIter = c1.begin(); cIter != c1.end(); cIter++)
		cout << " " << *cIter;
	cout << endl;

	return;
	/*
	c1 = 10 20 30
	c1 = 50 60
	c1 = 4 4 4 4 4 4 4
	请按任意键继续. . .
	*/
}

//返回指定位置的元素
void Deque_at(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(10);
	c1.push_back(20);

	const int& i = c1.at(0);
	int& j = c1.at(1);
	cout << "The first element is " << i << endl;
	cout << "The second element is " << j << endl;

	return;
	/*
	The first element is 10
	The second element is 20
	请按任意键继续. . .
	*/
}

//返回最末一个元素 
void Deque_back(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(10);
	c1.push_back(11);

	int& i = c1.back();
	const int& ii = c1.front();

	cout << "The last integer of c1 is " << i << endl;
	i--;
	cout << "The next-to-last integer of c1 is " << ii << endl;

	return;
	/*
	The last integer of c1 is 11
	The next-to-last integer of c1 is 10
	请按任意键继续. . .
	*/
}

//返回第一个元素的迭代器 
void Deque_begin(void)
{
	using namespace std;
	deque <int> c1;
	deque <int>::iterator c1_Iter;
	deque <int>::const_iterator c1_cIter;

	c1.push_back(1);
	c1.push_back(2);

	c1_Iter = c1.begin();
	cout << "The first element of c1 is " << *c1_Iter << endl;

	*c1_Iter = 20;
	c1_Iter = c1.begin();
	cout << "The first element of c1 is now " << *c1_Iter << endl;

	// The following line would be an error because iterator is const
	// *c1_cIter = 200;

	return;
	/*
	The first element of c1 is 1
	The first element of c1 is now 20
	请按任意键继续. . .
	*/
}

//清空所有元素
void Deque_clear(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);

	cout << "The size of the deque is initially " << c1.size() << endl;
	c1.clear();
	cout << "The size of the deque after clearing is " << c1.size() << endl;

	return;
	/*
	The size of the deque is initially 3
	The size of the deque after clearing is 0
	请按任意键继续. . .
	*/
}

//判断是否为空（返回true时为空）
void Deque_empty(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(10);
	if (c1.empty())
		cout << "The deque is empty." << endl;
	else
		cout << "The deque is not empty." << endl;

	return;
	/*
	The deque is not empty.
	请按任意键继续. . .
	*/
}

//返回最末元素的迭代器(译注:实指向最末元素的下一个位置)
void Deque_end(void)
{
	using namespace std;
	deque <int> c1;
	deque <int>::iterator c1_Iter;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);

	c1_Iter = c1.end();
	c1_Iter--;
	cout << "The last integer of c1 is " << *c1_Iter << endl;

	c1_Iter--;
	*c1_Iter = 400;
	cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

	// If a const iterator had been declared instead with the line:
	// deque <int>::const_iterator c1_Iter;
	// an error would have resulted when inserting the 400

	cout << "The deque is now:";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << " " << *c1_Iter;

	cout << endl;
	return;
	/*
	The last integer of c1 is 30
	The new next-to-last integer of c1 is 400
	The deque is now: 10 400 30
	请按任意键继续. . .
	*/
}

//删除指定元素 
void Deque_erase(void)
{
	using namespace std;
	deque <int> c1;
	deque <int>::iterator Iter;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);
	c1.push_back(40);
	c1.push_back(50);
	cout << "The initial deque is: ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << endl;
	c1.erase(c1.begin());
	cout << "After erasing the first element, the deque becomes:  ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << endl;
	Iter = c1.begin();
	Iter++;
	c1.erase(Iter, c1.end());
	cout << "After erasing all elements but the first, deque becomes: ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << endl;

	return;
	/*
	The initial deque is: 10 20 30 40 50
	After erasing the first element, the deque becomes:  20 30 40 50
	After erasing all elements but the first, deque becomes: 20
	请按任意键继续. . .
	*/
}

//返回第一个元素
void Deque_front(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(10);
	c1.push_back(11);

	int& i = c1.front();
	const int& ii = c1.front();

	cout << "The first integer of c1 is " << i << endl;
	i++;
	cout << "The second integer of c1 is " << ii << endl;
	return;
	/*
	The first integer of c1 is 10
	The second integer of c1 is 11
	请按任意键继续. . .
	*/
}

//返回内存分配器 
void Deque_get_allocator(void)
{

	using namespace std;
	// The following lines declare objects that use the default allocator.
	deque <int> c1;
	deque <int, allocator<int> > c2 = deque <int, allocator<int> >(allocator<int>());

	// c3 will use the same allocator class as c1
	deque <int> c3(c1.get_allocator());

	deque <int>::allocator_type xlst = c1.get_allocator();
	// You can now call functions on the allocator class used by c1

	return;
}

//插入元素到
void Deque_insert(void)
{
	using namespace std;
	deque <int> c1, c2;
	deque <int>::iterator Iter;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);
	c2.push_back(40);
	c2.push_back(50);
	c2.push_back(60);

	cout << "[ c1 = ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << "]" << endl;

	Iter = c1.begin();
	Iter++;
	c1.insert(Iter, 100);
	cout << "[ c1 = ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << "]" << endl;

	Iter = c1.begin();
	Iter++;
	Iter++;
	c1.insert(Iter, 2, 200);

	cout << "[ c1 = ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << "]" << endl;

	c1.insert(++c1.begin(), c2.begin(), --c2.end());

	cout << "[ c1 = ";
	for (Iter = c1.begin(); Iter != c1.end(); Iter++)
		cout << *Iter << " ";
	cout << "]" << endl;

	return;
	/*
	[ c1 = 10 20 30 ]
	[ c1 = 10 100 20 30 ]
	[ c1 = 10 100 200 200 20 30 ]
	[ c1 = 10 40 50 100 200 200 20 30 ]
	请按任意键继续. . .
	*/
}

//返回所能容纳元素的最大数量（上限）
void Deque_max_size(void)
{
	using namespace std;
	deque <int> c1;
	deque <int>::size_type i;

	i = c1.max_size();
	cout << "The maximum possible length of the deque is " << i << "." << endl;

	return;
	/*
	The maximum possible length of the deque is 1073741823.
	请按任意键继续. . .
	*/
}

//移除最后一个元素
void Deque_pop_back(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(1);
	c1.push_back(2);
	cout << "The first element is: " << c1.front() << endl;
	cout << "The last element is: " << c1.back() << endl;

	c1.pop_back();
	cout << "After deleting the element at the end of the deque, the "
		"last element is: " << c1.back() << endl;

	return;
	/*
	The first element is: 1
	The last element is: 2
	After deleting the element at the end of the deque, the last element is: 1
	请按任意键继续. . .
	*/
}

//在最后添加一个元素
void Deque_push_back(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(1);
	if (c1.size() != 0)
		cout << "Last element: " << c1.back() << endl;

	c1.push_back(2);
	if (c1.size() != 0)
		cout << "New last element: " << c1.back() << endl;

	return;
	/*
	Last element: 1
	New last element: 2
	请按任意键继续. . .
	*/
}

//将一个元素添加到双端队列的开头
void Deque_push_front(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_front(1);
	if (c1.size() != 0)
		cout << "First element: " << c1.front() << endl;

	c1.push_front(2);
	if (c1.size() != 0)
		cout << "New first element: " << c1.front() << endl;

	return;
	/*
	First element: 1
	New first element: 2
	请按任意键继续. . .
	*/
}

//返回尾部的逆迭代器
void Deque_rbegin(void)
{

	using namespace std;
	deque <int> c1;
	deque <int>::iterator c1_Iter;
	deque <int>::reverse_iterator c1_rIter;

	// If the following line had replaced the line above, an error 
	// would have resulted in the line modifying an element 
	// (commented below) because the iterator would have been const
	// deque <int>::const_reverse_iterator c1_rIter;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);

	c1_rIter = c1.rbegin();
	cout << "Last element in the deque is " << *c1_rIter << "." << endl;

	cout << "The deque contains the elements: ";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << *c1_Iter << " ";
	cout << "in that order.";
	cout << endl;

	// rbegin can be used to iterate through a deque in reverse order
	cout << "The reversed deque is: ";
	for (c1_rIter = c1.rbegin(); c1_rIter != c1.rend(); c1_rIter++)
		cout << *c1_rIter << " ";
	cout << endl;

	c1_rIter = c1.rbegin();
	*c1_rIter = 40;  // This would have caused an error if a 
	// const_reverse iterator had been declared as 
	// noted above
	cout << "Last element in deque is now " << *c1_rIter << "." << endl;

	return;
	/*
	Last element in the deque is 30.
	The deque contains the elements: 10 20 30 in that order.
	The reversed deque is: 30 20 10
	Last element in deque is now 40.
	请按任意键继续. . .
	*/
}

//返回起始的逆迭代器
void Deque_rend(void)
{
	using namespace std;

	deque <int> c1;
	deque <int>::iterator c1_Iter;
	deque <int>::reverse_iterator c1_rIter;
	// If the following line had replaced the line above, an error
	// would have resulted in the line modifying an element
	// (commented below) because the iterator would have been const
	// deque <int>::const_reverse_iterator c1_rIter;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);

	c1_rIter = c1.rend();
	c1_rIter--; // Decrementing a reverse iterator moves it forward 
	// in the deque (to point to the first element here)
	cout << "The first element in the deque is: " << *c1_rIter << endl;

	cout << "The deque is: ";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << *c1_Iter << " ";
	cout << endl;

	// rend can be used to test if an iteration is through all of 
	// the elements of a reversed deque
	cout << "The reversed deque is: ";
	for (c1_rIter = c1.rbegin(); c1_rIter != c1.rend(); c1_rIter++)
		cout << *c1_rIter << " ";
	cout << endl;

	c1_rIter = c1.rend();
	c1_rIter--; // Decrementing the reverse iterator moves it backward 
	// in the reversed deque (to the last element here)
	*c1_rIter = 40; // This modification of the last element would 
	// have caused an error if a const_reverse 
	// iterator had been declared (as noted above)
	cout << "The modified reversed deque is: ";
	for (c1_rIter = c1.rbegin(); c1_rIter != c1.rend(); c1_rIter++)
		cout << *c1_rIter << " ";
	cout << endl;

	return;
	/*
	The first element in the deque is: 10
	The deque is: 10 20 30
	The reversed deque is: 30 20 10
	The modified reversed deque is: 30 20 40
	请按任意键继续. . .
	*/
}

//改变元素数量的大小
void Deque_resize(void)
{
	using namespace std;
	deque <int> c1;

	c1.push_back(10);
	c1.push_back(20);
	c1.push_back(30);

	c1.resize(4, 40);
	cout << "The size of c1 is: " << c1.size() << endl;
	cout << "The value of the last element is " << c1.back() << endl;

	c1.resize(5);
	cout << "The size of c1 is now: " << c1.size() << endl;
	cout << "The value of the last element is now " << c1.back() << endl;

	c1.resize(2);
	cout << "The reduced size of c1 is: " << c1.size() << endl;
	cout << "The value of the last element is now " << c1.back() << endl;

	return;
	/*
	The size of c1 is: 4
	The value of the last element is 40
	The size of c1 is now: 5
	The value of the last element is now 0
	The reduced size of c1 is: 2
	The value of the last element is now 20
	请按任意键继续. . .
	*/
}

//返回元素数量的大小
void Deque_size(void)
{
	using namespace std;
	deque <int> c1;
	deque <int>::size_type i;

	c1.push_back(1);
	i = c1.size();
	cout << "The deque length is " << i << "." << endl;

	c1.push_back(2);
	i = c1.size();
	cout << "The deque length is now " << i << "." << endl;
	return;
	/*
	The deque length is 1.
	The deque length is now 2.
	请按任意键继续. . .
	*/
}

//交换
void Deque_swap(void)
{

	using namespace std;
	deque <int> c1, c2, c3;
	deque <int>::iterator c1_Iter;

	c1.push_back(1);
	c1.push_back(2);
	c1.push_back(3);
	c2.push_back(10);
	c2.push_back(20);
	c3.push_back(100);

	cout << "The original deque c1 is:";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << " " << *c1_Iter;
	cout << endl;

	c1.swap(c2);

	cout << "After swapping with c2, deque c1 is:";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << " " << *c1_Iter;
	cout << endl;

	swap(c1, c3);

	cout << "After swapping with c3, deque c1 is:";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << " " << *c1_Iter;
	cout << endl;

	swap<>(c1, c2);
	cout << "After swapping with c2, deque c1 is:";
	for (c1_Iter = c1.begin(); c1_Iter != c1.end(); c1_Iter++)
		cout << " " << *c1_Iter;
	cout << endl;

	return;
	/*
	The original deque c1 is: 1 2 3
	After swapping with c2, deque c1 is: 10 20
	After swapping with c3, deque c1 is: 100
	After swapping with c2, deque c1 is: 1 2 3
	请按任意键继续. . .
	*/
}