STL deque容器

STL中的容器：

deque容器的常用接口及用法：

---

deque：它被称作双端数组，可以在头部和尾部插入或删除数据；

---

deque 容器和 vector 容器的区别：

1.vector 容器对头部插入、删除数据的效率较低，因为 vector 容器是单端数组，若要从头部插入或删除，得把后面的数据都往后挪或往前挪，因此数据量越大，则其时间效率越低；

2.deque 容器相对 vector 容器而言，它对于头部插入数据或头部删除数据的效率就高多了，这与它的内部实现相关；

3.vector 容器访问单个数据的效率要高于 deque 容器，原因也是与 deque 容器的内部实现有关；

图片转自于黑马程序员，是在学习的过程中截图下来的

---

deque 容器内部工作原理：

1.deque 内部有个中控器，它维护着每段缓冲区中的内容，而缓冲区里面放着真实的数据；

2.中控器维护的其实是缓冲区的地址，使得使用 deque 容器时像一段连续的内存空间；

3.缓冲区的头和尾是没有插满数据的，因此可以继续添加。添加满后，则会开辟一块新的缓冲区，中控器则记录下新的缓冲区的地址；

4.由于中控器维护的是地址，因此当我们访问单个元素时，内部的实现是从地址再转到缓冲区，这里的时间效率就低于 vector 容器了；

图片转自于黑马程序员，是在学习的过程中截图下来的

---

各种函数接口具体如何使用，下面的代码块中会有详细的使用方法

---

deque 容器构造函数：

1.deque d; 默认（无参）构造；

2.deque(const deque & d); 拷贝构造函数

3.deque(begin,end); 把区间 [begin,end) 之间的数据拷贝到新创建的 deque 容器；

4.deque(n,elem); 把n个 elem 拷贝给新创建的 deque 容器；

#include 
#include   //使用STL中的容器，得包含它的头文件 
#include   //使用STL提供的算法，得包含它的头文件

using namespace std;

void printDeque(const deque<int> & d)  //限制传进来的deque容器只读的状态
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test_1()  //deque容器构造函数 
{
	int i = 0;
	deque<int> d1;  //默认（无参）构造函数 
	
	for(i=0;i<10;i++)
	{
		d1.push_back(i+1);
	}
	
	printDeque(d1);
	
	deque<int> d2(d1);  //拷贝构造函数
	printDeque(d2);
	
	deque<int> d3(d1.begin(),d1.end());  //把区间[d1.begin(),d1.end())之间的数据拷贝到新创建的deque容器
	printDeque(d3);
	
	deque<int> d4(10,1);  //把10个1拷贝到新创建的deque容器 
	printDeque(d4);
}


int main()
{
	test_1();
	
	system("pause");
	return 0;
} 

deque 容器赋值：

1.deque& operator=(const deque & d); 通过重载赋值运算符的方式给新创建的 deque 容器赋值；

2.assign(begin,end); 通过成员函数 assign() 把 [begin,end) 之间的数据给新创建的 deque 容器赋值；

3.assign(n,elem); 通过成员函数 assign() 把n个 elem 给新创建的 deque 容器赋值；

#include 
#include   //使用STL中的容器，得包含它的头文件 
#include   //使用STL提供的算法，得包含它的头文件

using namespace std;

void printDeque(const deque<int> & d)  限制传进来的deque容器只读的状态
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test_1()  //deque容器赋值
{
	int i = 0;
	deque<int> d1;  //默认（无参）构造函数 
	
	for(i=0;i<10;i++)
	{
		d1.push_back(i+1);
	}
	
	printDeque(d1);
	
	deque<int> d2;
	d2 = d1;  //通过重载赋值运算符的方式给新创建的deque容器赋值
	printDeque(d2);
	
	deque<int> d3;
	d3.assign(d1.begin(),d1.end());  //通过成员函数assign()把[begin,end)之间的数据给新创建的deque容器赋值
	printDeque(d3);
	
	deque<int> d4;
	d4.assign(10,1);  //通过成员函数assign()把10个1给新创建的deque容器赋值
	printDeque(d4);
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
} 

deque 容器的大小：

1.empty(); 判断 deque 容器是否为空，如果 deque 容器为空，则返回 true，否则返回 false；

2.size() 用于查看容器的大小（元素个数）；

3.resize(int num); 重新指定容器的大小为 num，若容器扩大了，则以默认值（0）来填充，若容器变小了，则删除多出来的部分；

4.resize(int num,int elem);

重新指定容器的大小为 num，若容器扩大了，则以 elem 来填充多出来的部分，若容器变小了，则删除多出来的部分；

注意：由于 deque 内部工作原理的特殊性，deque 容器没有容量的概念；

#include 
#include   //使用STL中的容器，得包含它的头文件 
#include   //使用STL提供的算法，得包含它的头文件

using namespace std;

void printDeque(const deque<int> & d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test_1()  //deque容器的大小 
{
	int i = 0;
	deque<int> d1;
	
	for(i=0;i<10;i++)
	{
		d1.push_back(i+1);
	}
	
	printDeque(d1);
	
	if(d1.empty())  //判断deque容器是否为空，如果deque容器为空，则返回true，否则返回false
	{
		cout << "当前容器为空" << endl;
	}
	else
	{
		cout << "当前容器不为空" << endl;
		cout << "d1的大小为：" << d1.size() << endl;  //用于查看容器的大小（元素个数）
	}
	
	d1.resize(20);  //重新指定容器的大小为20，容器扩大，以默认值（0）来填充
	printDeque(d1);
	
	d1.resize(25,10);  //重新指定容器的大小为25，容器扩大，以10来填充
	printDeque(d1);
	
	d1.resize(5);  //重新指定容器的大小为5，容器缩小，删除多出来的部分
	printDeque(d1);
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
} 

deque 容器插入和删除：

---

两端插入和删除：

1.push_back(elem); 在 deque 容器的尾部插入数据；

2.push_front(elem); 在 deque 容器的头部插入数据；

3.pop_back(); 在 deque 容器的尾部删除数据；

4.pop_front(); 在 deque 容器的头部删除数据；

---

指定位置的插入和删除：

1.insert(pos,elem); 通过迭代器在 deque 容器的指定位置插入一个 elem 元素；

2.insert(pos,n,elem); 通过迭代器在 deque 容器的指定位置插入n个 elem 元素；

3.insert(pos,begin,end); 通过迭代器在 deque 容器的指定位置插入区间 [begin,end) 的数据；

4.erase(pos); 通过迭代器删除掉 deque 容器指定位置的数据；

5.erase(begin,end); 通过迭代器删除掉 deque 容器区间 [begin,end) 之间的数据；

6.clear(); 清空当前的 deque 容器；

---

#include 
#include   //使用STL中的容器，得包含它的头文件 
#include   //使用STL提供的算法，得包含它的头文件

using namespace std;

void printDeque(const deque<int> & d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test_1()  //deque容器两端插入和删除 
{
	deque<int> d1;
	
	//尾插法 
	d1.push_back(10);
	d1.push_back(20);
	
	//头插法
	d1.push_front(100);
	d1.push_front(200);
	
	printDeque(d1);
	
	//尾删法
	d1.pop_back();
	
	//头删法
	d1.pop_front();
	
	printDeque(d1); 
}

void test_2()  //deque容器指定位置的插入和删除 
{
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);
	
	d1.insert(d1.begin(),5000);  //通过迭代器在deque容器的头部插入一个5000
	printDeque(d1);
	
	d1.insert(d1.end(),2,5000);  //通过迭代器在deque容器的尾部部插入两个5000
	printDeque(d1);
	
	deque<int> d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);
	
	d1.insert(d1.begin(),d2.begin(),d2.end());  //通过迭代器在d1的头部插入d2区间[d2.begin(),d2.end())的数据
	printDeque(d1);
	
	d1.erase(d1.begin());  //通过迭代器删除掉deque容器头部的数据
	printDeque(d1);
	
	deque<int>::iterator it = d2.begin(); 
	it++;
	d2.erase(it,d2.end());  //通过迭代器删除掉deque容器区间[it,end)之间的数据
	printDeque(d2);
	
	d1.clear();  //清空当前的deque容器
	printDeque(d1);
} 

int main()
{
	test_1();
	test_2();
	
	system("pause");
	return 0;
}

deque 容器数据存取：

1.operator[]; 通过重载 [] 的方式，获取 deque 容器的每一个元素；

2.at(int idx); 通过成员函数 at() 获取 deque 容器的每一个元素；

3.front(); 返回容器中的第一个元素；

4.back(); 返回容器中的最后一个元素；

#include 
#include   //使用STL中的容器，得包含它的头文件 
#include   //使用STL提供的算法，得包含它的头文件

using namespace std;

void test_1()  //deque容器数据存取 
{
	int i = 0;
	deque<int> d1;
	//300 200 100 10 20 30 
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_front(100);
	d1.push_front(200);
	d1.push_front(300);
	
	for(i=0;i<d1.size();i++)
	{
		cout << d1[i] << " ";  //通过重载[]的方式，获取deque容器的每一个元素
	}
	cout << endl;
	
	for(i=0;i<d1.size();i++)
	{
		cout << d1.at(i) << " ";  // 通过成员函数at()获取deque容器的每一个元素
	}
	cout << endl;
	
	cout << "第一个元素为：" << d1.front() << endl;  //返回容器中的第一个元素
	cout << "最后一个元素为：" << d1.back() << endl;  //返回容器中的最后一个元素
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

deque 容器排序：

1.sort(iterator begin,iterator end); 对区间 [begin,end) 之间的元素进行排序；（默认为从小到大，即升序）

注意：对于支持随机访问的迭代器，都可以直接利用 sort() 排序进行排序（sort()算法其实是 STL 中很常用的排序算法，STL 中的常用算法后续也会更新出来(●’◡’●)）；

---

这里提一嘴，STL中的常用算法只允许拥有 支持随机访问的迭代器 的容器使用，迭代器不支持随机访问 的容器是不可以使用这些常用算法的，但为了解决这样的问题，这些容器内置了一些成员函数，这些成员函数的功能与常用算法一致，这些成员函数就只能由对应的容器来使用了；

---

#include 
#include   //使用STL中的容器，得包含它的头文件 
#include   //使用STL提供的算法，得包含它的头文件

using namespace std;

void printDeque(const deque<int> & d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test_1()  //deque容器排序 
{
	int i = 0;
	deque<int> d1;
	//300 200 100 10 20 30 
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_front(100);
	d1.push_front(200);
	d1.push_front(300);
	
	cout << "排序前：" << endl;
	printDeque(d1);
	
	sort(d1.begin(),d1.end());  //对于支持随机访问的迭代器，都可以直接利用sort排序进行排序 
	cout << "排序后：" << endl;
	printDeque(d1);
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

---

以上就是STL中deque容器的一些常用接口和用法啦O(∩_∩)O。笔记中有错误的地方，欢迎指出，欢迎大家讨论！