序列式容器

最新推荐文章于 2024-05-19 22:14:54 发布
最新推荐文章于 2024-05-19 22:14:54 发布
阅读量122 收藏
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43422942/article/details/98621086
版权

Vector容器


//动态数组

#include<iostream>
#include<vector>

using namespace std;

void Print(vector<int>& v)
{
	//vector<int>::iterator迭代器类型
	for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//初始化
void text1()
{
	vector<int> v;  //默认参数构造

	int arr[] = {1,2,3,4};
	vector<int> v1(arr,arr + sizeof(arr) / sizeof(int));  //类似于下一种
	vector<int> v2(v1.begin(), v1.end());
	vector<int> v3(v2);

	//输出
	//for_each(v.begin(), v.end(), Print);  //第三个参数回调函数
	Print(v1);
	Print(v2);
	Print(v3);
}

//赋值
void text2()
{
	int v[] = { 10,20,30,40 };
	vector<int> v1(v, v + sizeof(v) / sizeof(int));

	vector<int> v2(v1.begin(), v1.end());

	//重载
	vector<int> v3;
	v3 = v2;

	int arr[] = { 100,200,300,400 };
	vector<int> v4(arr, arr + sizeof(v) / sizeof(int));

	Print(v1);
	Print(v2);
	Print(v3);
	Print(v4);
	cout << "交换后:" << endl;

	v1.swap(v4);  //交换

	Print(v1);
	Print(v2);
	Print(v3);
	Print(v4);
}

//大小操作
void text3()
{
	int arr[] = { 10,20,30,40 };
	vector<int> v(arr, arr + sizeof(arr) / sizeof(int));

	cout << "容器的元素个数：" << v.size() << endl;
	if (v.empty())
	{
		cout << "空" << endl;
	}
	else
	{
		cout << "不空！" << endl;
	}
	Print(v);
	//重新指定容器的大小
	v.resize(2);  
	Print(v);
	v.resize(4, 1);
	Print(v);

	for (int i = 0; i < 1000; i++)
	{
		v.push_back(i);
	}
	cout << "容器的元素个数：" << v.size() << endl;
	cout << "容器的容量：" << v.capacity() << endl;  //大于等于元素个数

}

//存储数据
void text4()
{
	int arr[] = { 10,20,30,40 };
	vector<int> v(arr, arr + sizeof(arr) / sizeof(int));

	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";    //不抛异常
	}
	cout << endl;
	for (int i = 0; i < v.size(); i++)
	{
		cout << v.at(i) << " ";  //at抛异常
	}
	cout << endl;

	cout << "第一个元素：" << v.front() << endl;
	cout << "最后一个元素：" << v.back() << endl;
}

//插入和删除
void text5()
{
	vector<int> v;
	//添加元素
	v.push_back(10);
	v.push_back(20);
	//插入元素
	v.insert(v.begin(), 30);
	v.insert(v.end(), 100);
	v.insert(v.begin() + 2, 5000);  //支持随机访问
	Print(v);

	//删除最后一个元素
	v.pop_back();
	Print(v);
	v.erase(v.begin());
	Print(v);
	v.erase(v.begin() + 1, v.end());
	Print(v);
	v.clear();   //清除容器元素

	cout << "元素大小：" << v.size() << endl;

}

//swap收缩空间
void text6()
{
	vector<int> v;
	for (int i = 0; i < 10000; i++)
	{
		v.push_back(i);
	}

	cout << "大小:" << v.size() << endl;
	cout << "容量:" << v.capacity() << endl;

	v.resize(10);
	cout << "***************" << endl;
	cout << "大小:" << v.size() << endl;
	cout << "容量:" << v.capacity() << endl;

	//收缩空间
	vector<int>(v).swap(v);
	cout << "***************" << endl;
	cout << "大小:" << v.size() << endl;
	cout << "容量:" << v.capacity() << endl;

}

//reserve 预留空间
void text7()
{
	int num = 0;
	int* address = NULL;
	vector<int> v;

	v.reserve(100000);  //提前知道容器大概要存储的元素个数 可以使用reserve预留空间 提高效率

	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
		if (address != &(v[0]))
		{
			address = &v[0];
			num++;
		}
	}

	cout << "num:" << num << endl;
}

int main()
{
	//text1();
	//text2();
	//text3();
	//text4();
	//text5();
	//text6();
	text7();


	return 0;
}

String容器

#include<iostream>
#include<string>

using namespace std;

//初始化
void text1()
{
	string s1;
	string s2(10, 'a');
	string s3("sadmoney");
	string s4(s3);	//拷贝构造
	
	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
}

//赋值操作
void text2()
{
	string s = "abcdefg";

	//重载[]操作符   无法处理越界 
	for (int i = 0; i < s.size(); i++)
	{
		cout << s[i] << " ";
	}
	cout << endl;
	//at成员函数
	for (int i = 0; i < s.size(); i++)
	{
		cout << s.at(i) << " ";
	}
	cout << endl;
}

//拼接操作 加入尾部
void text3()
{
	string s = "11111";
	string s2 = "abcdef";
	s += "222222";
	s += s2;
	cout << s << endl;

	string s3 = "asd";
	s2.append(s3);
	cout << s2 << endl;

	string s4 = s2 + s3;
	cout << s4 << endl;
}

//查找操作
void text4()
{
	string s = "asdfgjhkfgi";
	//查找第一次出现的位置
	int pos = s.find("fg");
	cout << pos << endl;
	//查找最后一次出现的位置
	int prs = s.rfind("fg");
	cout << prs << endl;
}

//替换操作
void text5()
{
	string s = "abcdefg";
	s.replace(0, 2, "111");
	cout << s << endl;
}

//比较操作
void text6()
{
	string a = "abcd";
	string b = "abce";
	if (a.compare(b)==0)
	{
		cout << "相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
}

//子串操作
void text7()
{
	string s = "abcdefg";
	string ps = s.substr(1, 3);
	cout << ps << endl;
}

//插入删除
void text8()
{
	string s = "abcdefg";
	s.insert(3, "123");
	cout << s << endl;

	s.erase(0, 2);  //从第0个位置开始删除两个元素
	cout << s << endl;
}

int main()
{
	//text1();
	//text2();
	//text3();
	//text4();
	//text5();
	//text6();
	//text7();
	text8();


	return 0;
}

List容器


//链表

#include<iostream>
#include<list>

using namespace std;

void Print(list<int>& ls)
{
	for (list<int>::iterator i = ls.begin(); i != ls.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
}

//初始化
void text1()
{
	list<int> ls1;
	list<int> ls2(10,5);	//有参构造
	list<int> ls3(ls2);		//拷贝构造
	list<int> ls4(ls2.begin(), ls2.end());

	Print(ls2);

}

//插入删除
void text2()
{
	list<int> ls;
	ls.push_back(100);	
	ls.push_back(300);
	ls.push_front(200);
	ls.push_front(200);	//ls.insert(ls.begin, 200); 一样
				
	//ls.insert(ls.begin + 1, 500);  错误
	list<int>::iterator it = ls.begin();
	it++; 
	ls.insert(it, 500);

	Print(ls);

	//ls.pop_back();
	//ls.pop_front();
	//ls.erase(ls.begin(), ls.end()); //ls.chear();

	ls.remove(200);	//删除匹配的所有值
	Print(ls);
}

//赋值操作
void text3()
{ 
	list<int> ls;
	ls.assign(10, 10);
	list<int> ls2;
	ls2 = ls;

	ls2.swap(ls);	//交换

}

//反转
void text4()
{
	list<int> ls;
	for (int i = 0; i < 10; i++)
	{
		ls.push_back(i);
	}
	Print(ls);

	//元素反转
	ls.reverse();
	Print(ls);
}

//排序
bool Big(int a, int b)		//从大到小排序回调函数
{
	return a > b;
}

void text5()
{
	list<int> ls;
	ls.push_back(20);
	ls.push_back(40);
	ls.push_back(10);
	ls.push_back(50);
	Print(ls);

	ls.sort();	//默认从小到大
	Print(ls);

	ls.sort(Big);	//从大到小
	Print(ls);

	//算法中的sort只支持可随机访问的容器 list不支持随机访问
}

int main()
{
	//text1();
	//text2();
	//text4();
	text5();


	return 0;
}

Stack容器

//栈 先进后出

#include<iostream>
#include<stack>

using namespace std;


void text1()
{
	//初始化
	stack<int> s1;
	stack<int> s2(s1);

	//进栈
	s1.push(10);
	s1.push(20);
	s1.push(30);
	// 30 20 10
	cout << "栈顶元素：" << s1.top() << endl;
	s1.pop();	//删除栈顶元素

	s1.push(50);

	cout << "打印栈元素:" << endl;
	while (!s1.empty())
	{
		cout << s1.top() << " ";
		s1.pop();
	}
	cout << endl;

	cout << "size:" << s1.size() << endl;

}

int main()
{
	text1();

	return 0;
}

Deque容器


//双端数组

#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 text1()
{
	deque<int> d1;
	deque<int> d2(10, 5);  //10个5
	deque<int> d3(d2.begin(), d2.end());   //迭代器构造
	deque<int> d4(d3);	//构造函数构造

	Print(d4);
}

//赋值和大小操作
void text2()
{
	deque<int> d1;
	deque<int> d2;
	deque<int> d3;
	d1.assign(10, 5);  //10个5
	d2.assign(d1.begin(), d1.end());   //迭代器指定区间赋值
	d3 = d2;		//等号赋值

	d1.swap(d2);   //交换两个空间的元素

	if (d1.empty())
	{
		cout << "空！" << endl;
	}
	else
	{
		cout << "不空！" << endl;
	}

	d1.size();	//元素大小
	d2.resize(10, 5);   //少了用5补充
}

//插入删除
void text3()
{
	deque<int> d;
	d.push_back(100);	//尾部插入
	d.push_front(500);	//头部插入
	d.push_back(200);
	d.push_front(300);

	Print(d);	//300 500 100 200

	int val = d.front();	//拿到第一个元素
	d.pop_front();		//无返回值 删除第一个元素

	int val2 = d.back();	//拿到最后一个元素
	d.pop_back();		//删除最后一个元素

}

int main()
{
	//text1();
	//text2();
	text3();


	return 0;
}

Queue容器


//双端数组

#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 text1()
{
	deque<int> d1;
	deque<int> d2(10, 5);  //10个5
	deque<int> d3(d2.begin(), d2.end());   //迭代器构造
	deque<int> d4(d3);	//构造函数构造

	Print(d4);
}

//赋值和大小操作
void text2()
{
	deque<int> d1;
	deque<int> d2;
	deque<int> d3;
	d1.assign(10, 5);  //10个5
	d2.assign(d1.begin(), d1.end());   //迭代器指定区间赋值
	d3 = d2;		//等号赋值

	d1.swap(d2);   //交换两个空间的元素

	if (d1.empty())
	{
		cout << "空！" << endl;
	}
	else
	{
		cout << "不空！" << endl;
	}

	d1.size();	//元素大小
	d2.resize(10, 5);   //少了用5补充
}

//插入删除
void text3()
{
	deque<int> d;
	d.push_back(100);	//尾部插入
	d.push_front(500);	//头部插入
	d.push_back(200);
	d.push_front(300);

	Print(d);	//300 500 100 200

	int val = d.front();	//拿到第一个元素
	d.pop_front();		//无返回值 删除第一个元素

	int val2 = d.back();	//拿到最后一个元素
	d.pop_back();		//删除最后一个元素

}

int main()
{
	//text1();
	//text2();
	text3();


	return 0;
}
寰宇huyu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第四章 序列式容器（sequence containers）
weixin_50866517的博客
03-15 1963
序列式容器（sequence containers）1.容器的概观与分类2.vector3.list4.deque5.stack6.queue7.heap(隐私表述,implicit representation)8.priority_queue9.slist 1.容器的概观与分类 研究数据的特定排列方式，以利于搜寻或排序或其它特殊目的，称为数据结构(DataStructures)。任何特定的数据 结构都是为了实现某种特定的算法。 STL容器即是将运用最广的一些数据结构实现出来（如下图所示)。未来，在每五
4. 序列式容器
hello_dear_you的博客
12-28 697
STL的序列式容器学习
C++基础与深度解析 | 序列容器 | 关联容器 | 适配器与生成器
最新发布
zwcslj的博客
05-19 959
C++ 标准库提供了多种容器，它们是用于存储和操作数据集合的模板类。每种容器都有其特定的用途和特点，以及支持的基本操作。
(二) 序列容器
qq_23123181的博客
01-29 1549
1、序列式容器是什么？ 序列容器以线性序列的方式存储元素。它没有对元素进行排序，元素的顺序和存储它们的顺序相同。 array<T,N>(数组容器)是一个长度固定的序列，有N个T类型的对象，不能增加或删除元素 vector<T>(向量容器)是一个长度可变的序列，用来存放T类型的对象。必要时，可以自动增加容量，但只能在序列的末尾高效地增加或删除元素。 deque<T>（双向队列容器）是一个长度可变的，可以自动增长的序列，在序列的两端都不能高效地增加或删除元素。 li
STL——序列式容器的总结
wzmroot
07-28 749
序列式容器（Sequence Containers）：所谓序列式容器，其中的元素都可序（ordered),但未必有序（sorted)。C++语言本身提供了一个序列式容器array,STL另外再提供了vector,list,deque,stack,queue,priority-queue等等序列式容器。其中stack和queue由于只是将deque改头换面而成，技术上被归类为一种配接器（adapte
序列式容器简介
qq_26548003的博客
01-09 541
所谓序列式容器，表示其中的元素都是可以排序的，但未必是有序的。 C++本身提供了一个序列式容器数组array，STL另外有vector,list,deque,stack,queue,priority-queue等等序列式容器。stack和queue由于只是将deque封装得到的，技术上被归类为一种适配器(adapter)。 vector vector与array在数据安排和操作方式上很相似。两者的...
关联式容器序列式容器对比
12-21
这些容器不像序列式容器（如vector、list）那样有明显的头部和尾部，也不提供push_back、push_front、pop_back、pop_front等操作。相反，关联式容器主要提供了对元素基于键值的快速查找、插入和删除功能，这得益于...
STL关联容器入门
02-10
STL关联容器入门
STL -容器,string容器
08-26
STL容器可以分为两大类：序列式容器和关联式容器。 序列式容器的特点是强调值的排序，每个元素均有固定的位置。常见的序列式容器有vector、list、deque等。 关联式容器的特点是无需强调元素的物理顺序，各元素之间...
关于STL中list容器的一些总结
12-26
list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的...
Python使用容器中常用代码
02-19
在Python编程语言中，容器是数据结构的一种，用于存储和管理数据集合。这些容器包括列表（list）、元组（tuple）、集合（set）和字典（dictionary），它们各自有不同的特性和用途，对于开发者来说是非常重要的工具。...
STL:序列式容器vector总结
Dandelion_gong的博客
05-12 4202
说起数组我们都不陌生，但在C++中，除了数组还多了一个“新朋友”那就是vector。其实vector本质上与array的数据安排以及操作方式也其为相似。它俩唯一的差别就是空间灵活性。无论在C语言还是C++中，array的空间一旦申请完成就不能进行更改，如果需要更大空间来存储数据，便得重新申请一个新的数组并将原来的数值拷贝过去，然后再将原来数组释放，而这一切都需要用户自己完成。而vector不同的是，
STL笔记（8）—序列式容器之vector（一）
上善若水
04-12 1350
STL序列式容器简介
STL序列容器（sequence containers）常用操作
Code is poetry
10-08 879
Vector deque list forwa_list Stack Queue Vector： vector是动态数组，支持列表初始化即，vector&lt;int&gt; vect{1, 2, 3}; 系统自动分配内存，支持随机访问，除了在尾端插入和删除，其他地方的操作需要O(n)。 常用到的插入，删除，查找： vector&lt;int&gt; vect; //Inser...
序列式容器与关联式容器
try_again_later的博客
08-01 2097
0、序列式容器 vector 一、vector6种初始化 1、vector<int> vec1;// 默认初始化，vector为空，size为0，需要动态添加 2、vector<int> vec1(7);//包含7个缺省的值初始化，即7个0. 3、vector<int> vec1(7,3);// 包含7个值为3的int 4、vecto...
C++序列式容器vector，deque，list
FAS ------ 一颗好奇心，一页好代码！
07-06 948
vector，deque，list定义于namespace std中，这三者是STL的序列式容器，也就是元素的位置和你置入元素的方式顺序有关系，三者在存储方式上有很大不同，处于程序运行效率，不同的存储方式，也就提醒我们在不同的应用场景中我们应该选择哪种容器。下面是三者的存储结构示意图： 如图1 vector的存储示意图所示,vector采用动态数组的方式存储元素，一个vector当前所拥有的内容
STL之顺序容器和关联容器总结
lhc548453346的博客
03-07 2482
顺序容器          Vector中所采用的数据结构非常简单：线性连续空间。当分配空间被占满而仍然需要添加元素时，vector便会进行一场空间重新配置的大工程！在这里，程序员需要注意的是，一旦引起空间重新配置，之前指向原vector的所有迭代器就都失效了，这一点在工程中容易引起bug。          List则对空间的运用有绝对的精准，一点也不浪费。注意，list内部构成的实际是一个
序列型容器概述
weixin_42251246的博客
08-08 156
序列型容器概述vector vector 定义在头文件< vector >中 实际上就是一个动态数组。随机存取任何元素都能在常数时间内完成。在尾端增删元素具有较佳的性能。 ...
序列式容器和关联式容器
05-27
序列式容器和关联式容器是STL中的两种不同类型的容器。 序列式容器是按照元素在容器中的位置存储和访问元素的。常见的序列式容器包括vector、deque、list、forward_list等。 关联式容器是根据元素的键来存储和访问...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值