• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

STL deque容器

互联网 diligentman 2周前 (04-06) 8次浏览

STL中的容器:

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


deque:它被称作双端数组,可以在头部和尾部插入或删除数据;


deque 容器和 vector 容器的区别

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

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

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

STL  deque容器

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


deque 容器内部工作原理:

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

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

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

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

STL  deque容器

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


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


deque 容器构造函数:

1.deque<T> d; 默认(无参)构造;

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

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

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

#include <iostream>
#include <deque>  //使用STL中的容器,得包含它的头文件 
#include <algorithm>  //使用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 <iostream>
#include <deque>  //使用STL中的容器,得包含它的头文件 
#include <algorithm>  //使用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 <iostream>
#include <deque>  //使用STL中的容器,得包含它的头文件 
#include <algorithm>  //使用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 <iostream>
#include <deque>  //使用STL中的容器,得包含它的头文件 
#include <algorithm>  //使用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 <iostream>
#include <deque>  //使用STL中的容器,得包含它的头文件 
#include <algorithm>  //使用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 <iostream>
#include <deque>  //使用STL中的容器,得包含它的头文件 
#include <algorithm>  //使用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。笔记中有错误的地方,欢迎指出,欢迎大家讨论!


程序员灯塔
转载请注明原文链接:STL deque容器
喜欢 (0)