STL-deque容器和stack容器

最新推荐文章于 2024-04-12 22:13:54 发布
最新推荐文章于 2024-04-12 22:13:54 发布
阅读量243 收藏
点赞数
分类专栏： STL 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/128619603
版权

目录

一、deque容器

1. 基本概念

2. 构造函数 

3. 赋值

4. 大小操作

5. 插入和删除

头插、头删、尾插、尾删 

任意位置插入和删除

6. 数据的存取

7. 综合应用

 二、stack容器

一、deque容器

1. 基本概念

  • 功能：双端数组，可以对头端进行插入删除操作
  • deque和vector区别：
  • vector对于头端的插入和删除效率低，数据量越大，效率越低
  • deque相对而言，对头部的插入删除速度会比vector快
  • vector访问元素时的速度会比deque快，这两者内部实现有关 

2. 构造函数 

deque<T>d1;//默认构造形式
deque<T>d2(d.begin(), d.end());//构造函数将容器d的begin至end区间的元素拷贝给d2
deque<T>d3(int n,T elem);//将任意类型的n个elem元素拷贝给d3容器
deque<T>d4(d3);//将d3容器拷贝给d4容器
#include<iostream>
#include<deque>
using namespace std;
void print(const deque<int>d)//打印，加入const是让容器只能进行读的操作，不能修改（即不能进行*it赋值）
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//*it = 100;此时不能进行写的操作
		cout << *it << " ";
	}
	cout << endl;
}
void print2(deque<int>d)
{
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
	{
		*it = 100;//上面定义的是普通迭代器，因此此处可以进行“写”的操作
		cout << *it << " ";
	}
}
void text()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);//插入数据
	}
	print(d1);//输出0 1 2 3 4 5 6 7 8 9

	deque<int>d2(d1.begin(), d1.end());
	print(d2);//输出0 1 2 3 4 5 6 7 8 9

	deque<int>d3(10,11);
	print(d3);//输出11 11 11 11 11 11 11 11 11 11

	deque<int>d4(d3);
	print(d4);//输出11 11 11 11 11 11 11 11 11 11
}
int main()
{
	text();
	return 0;
}

3. 赋值

deque<T>d,d1,d2, d3;
d1 = d;//将d容器中的数据赋值给d1
d2.assign(d1.begin(),d1.end());//将d1容器从第一个元素到最后一个元素都赋值给d2
d3.assign(int n, T elem);//将n个T类型的数据elem赋值给d3容器
#include<iostream>
#include<deque>
using namespace std;
void print(deque<int>d)
{
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void text()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);//插入数据
	}
	print(d1);//输出0 1 2 3 4 5 6 7 8 9

	//等号“=”赋值
	deque<int> d2;
	d2 = d1;
	print(d2);//输出0 1 2 3 4 5 6 7 8 9

	//assign赋值
	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	print(d3);//输出0 1 2 3 4 5 6 7 8 9

	deque<int>d4;
	d4.assign(10, 11);
	print(d4);//输出 11 11 11 11 11 11 11 11 11 11

}
int main()
{
	text();
	return 0;
}

4. 大小操作

deque<T>d, d1;
d1.empty();//判断容器是否为空
d2.size();//计算容器中元素个数
d3.resize(int n);//重新指定长度n，若容器变长，默认用0填充新位置；若容器变短，则末尾超出容器长度的元素被删除
d4.resize(int n, T elem);//重新指定长度n，若容器变长，用elem填充新位置；若容器变短，则末尾超出容器长度的元素被删除
#include<iostream>
#include<deque>
using namespace std;
void print(const deque<int>d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void text()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);//插入数据
	}
	print(d1);//输出0 1 2 3 4 5 6 7 8 9

	if (d1.empty())//判空
	{
		cout << "容器为空！" << endl;
	}
	else
	{
		cout << "不为空！" << " ";
		cout <<"大小为："<< d1.size() << endl;
	}

	//重新指定大小
	d1.resize(16);//指定大小比原来长，剩下部分默认用0填充
	//d1.resize(16,1);剩下部分用1填充
	print(d1);
	d1.resize(4,3);//输出0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0
	print(d1);//输出0 1 2 3
}
int main()
{
	text();
	return 0;
}

5. 插入和删除

  • 头插、头删、尾插、尾删 

deque<T>d;
d.push_back(T elem);//尾部插入T类型的数据elem
d.push_front(T elem);//头部插入T类型的数据elem
d.pop_back();//删除尾部最后一个数据
d.pop_front();//删除头部最后一个数据
#include<iostream>
#include<deque>
using namespace std;
void print(const deque<int>d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void text()
{
	deque<int>d1;
	//尾插
	d1.push_back(11);
	d1.push_back(12);
	d1.push_back(13);
	print(d1);//输出11 12 13

	//头插
	d1.push_front(100);
	d1.push_front(200);
	print(d1);//输出200 100 11 12 13

	//尾删
	d1.pop_back();
	print(d1);//输出200 100 11 12

	//头删
	d1.pop_front();
	print(d1);//输出100 11 12	
}
int main()
{
	text();
	return 0;
}

  • 任意位置插入和删除

deque<T>d;
d.insert(pos,T elem);//在pos位置插入一个T类型的elem元素
d.insert(pos,int n,T elem);//在pos位置插入n个T类型的elem元素
d.insert(pos,beg,end);//在pos位置插入[beg,end]区间的所有元素
d.erase(beg,end);//删除[beg,end]区间的数据，返回下一数据的位置
d.erase(pos);//删除pos位置的数据，返回下一个数据的位置
d.clear();//清空容器中所有数据
#include<iostream>
#include<deque>
using namespace std;
void print(const deque<int>d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void text()
{
	deque<int>d1;
	//插入
	d1.insert(d1.begin(), 11);
	d1.insert(d1.begin(), 22);
	d1.insert(d1.begin(),3, 33);
	print(d1);//输出33 33 33 22 11

	d1.insert(d1.begin(),d1.begin(), d1.end());//头插[begin,end]区间的数据
	print(d1);//输出33 33 33 22 11 33 33 33 22 11

	d1.insert(d1.begin()+4, 66);//在下标为4的位置处插入66
	print(d1);//输出33 33 33 22 66 11 33 33 33 22 11

	//删除
	d1.erase(d1.begin()+2);//删除下标为2处的数据
	print(d1);//输出33 33 22 66 11 33 33 33 22 11

	d1.erase(d1.begin() + 1, d1.end() - 3);
	print(d1);//输出33 33 22 11

	//清空
	d1.erase(d1.begin(), d1.end());
	print(d1);
	//或者d1.clear();
}
int main()
{
	text();
	return 0;
}

6. 数据的存取

deque<T>d;
d.at(int i);//返回下标为i的元素
d.front();//返回第一个元素
d.back();//返回最后一个元素
#include<iostream>
#include<deque>
using namespace std;
void text()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		int x = rand() % 200 + 1;//产生1-200的任意随机数
		d1.push_back(x);
	}
	//利用[]方式访问
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1[i] << " ";
	}//输出42 68 135 101 170 125 79 159 163 65
	cout << endl;
	//利用at访问
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1.at(i) << " ";
	}输出42 68 135 101 170 125 79 159 163 65
	cout << endl;

	cout << "第一个元素是：" << d1.front() << endl;//输出42
	cout << "最后一个元素是：" << d1.back() << endl;//输出65
}
int main()
{
	text();
	return 0;
}

7. 综合应用

  •  实现10名学生的成绩由低到高排序
#include<iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
using namespace std;
class Student
{
public:

	Student(string N_name, int S_score)
	{
		this->name = N_name;
		this->score = S_score;
	}
	string name;//姓名
	int score;//分数
	~Student()
	{
		;
	}
};
void swap(vector<Student>& a, vector<Student>& b)
{
	vector<Student> tmp;
	tmp = a;
	a = b;
	b = tmp;
}
void Creat(vector<Student>&v)
{
	string s[10];//s容器存放姓名
	deque<int>d;//d容器存放分数
	for (int i = 0; i < 10; i++)
	{
		char a = rand() % 26 + 65;//产生A-Z(65-90)之间任意大写字母
		s[i].assign(1, a);//将字符a赋值给s[i]
		s[i] = "学生" + s[i];

		int x = rand() % 41 + 60;//产生60-100之间任意随机整数
		d.push_back(x);

		Student stu(s[i], d[i]);
		v.push_back(stu);
	}

	//采用冒泡排序
	for (int i = v.size() - 1; i > 0; i--)//扫描次数
	{
		for (int j = 0; j < i; j++)
		{
			if (v[j].score > v[j + 1].score)
			{
				swap(v[j], v[j + 1]);
			}
		}
	}
	//直接插入排序
	//for (int i = 1; i < v.size() ; i++)//扫描次数
	//{
	//	Student s = v[i];
	//	for (int j =i-1; j >=0; j--)
	//	{
	//		if (s.score < v[j].score)
	//		{
	//			swap(v[j+1], v[j]);
	//		}
	//	}
	//}
}

void print(vector<Student>v)
{
	for (vector<Student>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout  << it->name << "  分数：" << it->score << endl;
	}
}

int main()
{
	vector<Student>v;
	Creat (v);
	print(v);
	return 0;
}

 二、stack容器

  • 概念：stack是一种先进后出的数据结构，它只有一个出口，栈中只有顶端元素才可以被外界使用，因此栈不允许有遍历行为
stack<T>s;//默认构造
s.push(T elem);//T类型的数据elem进栈
s.pop();//栈顶元素出栈
s.top();//返回栈顶元素
s.size();//返回栈的大小
s.empty();//判空
#include<iostream>
#include<stack>
using namespace std;
void text()
{
	stack<int>s;//默认构造
	for (int i = 0; i < 10; i++)
	{
		int x = rand() % 100 + 1;//产生1-100任意随机数
		s.push(x);//入栈
	}
	cout << "栈的大小为：" << s.size() << endl;
	while (!s.empty())//栈不为空
	{
		cout << "栈顶元素：" << s.top() <<endl;
		s.pop();//出栈
	}

	cout << "栈的大小为：" << s.size() << endl;
}
int main()
{
	text();
	return 0;
}

 

莫忘、莫念
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java容器之Stack和Deque
Black的博客
10-14 1796
Java容器之Stack和Deque Stack Java的集合类并没有单独的Stack接口，有一个遗留类叫做Stack（栈，后进先出）。主要方法如下图所示： 在Java Doc里建议使用Deque接口替代Stack完成栈的功能，为什么呢？ 因为Stack是继承Vector，Vector是由数组实现线程安全（方法使用synchronized修饰）的集合类，它包含了大量集合处理的方法，而Stack复用了Vector的方法实现进栈和出栈的操作，基于数组实现相比于链表实现，效率上受影响。同时，因为继承Vect
Java中Deque和Stack的区别
qq_45450889的博客
06-15 622
综上，Stack和Deque虽然都是使用Java实现栈的类，但它们具有不同的接口、实现方式和用途，需要根据具体的情况选择合适的类。Java中Deque和Stack都是用于实现栈（stack）数据结构的类，但它们有一些区别。
探索Java中的栈：Stack与Deque（ArrayDeque和LinkedList）
最新发布
lph159的博客
04-12 1598
在Java中，栈可以通过Stack类来实现。Stack类是Java集合框架的一部分，它实现了一个后进先出（LIFO）的数据结构。Stack;双端队列（Deque）是一种更加通用的数据结构，它同时支持在队列两端进行插入和删除操作。在Java中，Deque是一个接口，它有多种实现方式，如ArrayDeque、LinkedList等。
[算法]LeetCode每日一题--739每日温度(Java)
shinezzz的博客
06-11 718
DailyChallenge 739. 每日温度 20200611 难度：中等 题目描述1 根据每日 气温 列表，请重新生成一个列表，对应位置的输出是需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0 来代替。 例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。 提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在
STL--deque、stack、queue
weixin_44627813的博客
05-01 2207
一、deque介绍 deque(双端队列)：是一种双开口的“连续”空间的数据结构。双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不必搬动数据；与list相比，空间利用比较高。 deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图： deque采用一块所谓的map(注意：不是STL的map容器)作为主控，这里的map是一小块连续空间，其中每个元素都是一个指针，指向另一段（
【Java】Stack和Deque
RiceVan的博客
08-31 1861
Deque替代Stack
STL之deque容器
Sunrise的博客
06-12 411
STL之deque容器
STL——deque容器
weixin_45149964的博客
10-18 129
功能：双端数组，可以对头端进行插入删除操作 deque与vector区别： 1.vector对于头部的插入删除效率低，数据量越大，效率越低 2.deque相对而言，对头部的插入删除速度比vector快 3.vector访问元素时的速度比deque快，这是因为两者的内部实现不同 deque内部工作原理： 内部有中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据 中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间 deque容器的迭代器也是支持随机访问 de
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
STL常用容器详细解析
09-05
本文主要探讨STL中的常用容器，包括顺序性容器（vector、deque、list）、关联容器（map、set）以及容器适配器（queue、stack）。 1. 顺序性容器 - (1) vector vector是一种动态数组，其内存空间是连续的，支持...
深入解析C++ STL中的常用容器
09-05
在STL中，容器是用于存储和管理数据的主要工具。本篇文章将深入解析C++ STL中的一些常用容器，包括顺序性容器、关联容器以及容器适配器。 1. 顺序性容器 - (1) vector `vector` 是一种动态数组，内存中存储是连续...
C++标准模板库(STL) -容器
11-05
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。...
STL-General.rar_STL
09-21
容器是用来存储元素的类模板，如vector、list、deque、set和map等，它们提供了不同类型的元素组织方式。迭代器则充当容器中的指针，可以用来遍历容器内的元素，并支持多种操作，如前向、反向、随机访问等。算法是...
Java集合—Deque & Stack
sanmi8276的博客
11-18 379
原文作者：惊帆的BLOG 原文地址：Java中的Deque和Stack的内部原理区别 关于Deque 和 Stack，如果没有对API有很仔细的研究，单纯从使用上来说，很难仔细发现他们中间的区别，虽然他们有很大不同。而实际在Java Doc里是建议用Deque替代Stack接口完成栈的功能，我们仔细看下Java Doc里对Stack是这样描述的： A more complete and consistent set of LIFO stack operations is provided by .
【数据结构】vector、deque、list、stack的对比
YaoJinTao2003的博客
11-27 586
【数据结构】vector、deque、list、stack的对比
Java笔记之Deque与Stack
来自蒟蒻LebronGod的博客
03-17 5982
使用Deque 允许两头都进，两头都出，这种队列叫双端队列（Double Ended Queue），简称Deque。 Java集合提供了接口Deque来实现一个双端队列，它的功能： ①既可以添加到队尾，也可以添加到队首； ②既可以从队首获取，又可以从队尾获取。 在原来的queue的方法名上加了表示在队首还是队尾操作的表示（Last或First）。 Deque接口实际上扩展自Queue： publ...
Java中的栈Stack、Deque、ArrayDeque、LinkedList
热门推荐
编程架构三分天下：分层、分治、分时序。
10-12 1万+
文章目录先来说说Java中的Stack类不用Stack至少有以下两点原因该用ArrayDeque还是LinkedList？结论 先来说说Java中的Stack类 Java中Stack类从Vector类继承，底层是用数组实现的线程安全的栈。栈是一种后进先出(LIFO)的容器，常用的操作push/pop/peek。 不过Java中用来表达栈的功能（push/pop/peek），更适用的是适用双端队列接口Deque，并用ArrayDeque/LinkedList来进行初始化。 Deque<Integer&g
java中的栈Stack与Deque
qq_53373885的博客
12-13 611
java中的栈Stack与Deque
c++ stl容器：栈（stack）
06-28
回答3：</h3><br/>栈（stack）是 C++ STL（Standard Template Library）中常见的一种容器数据结构，它可以在一端进行元素的插入和删除操作，遵循“后进先出”（LIFO，Last-In-First-Out）的原则。栈的操作不需要访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值