序列式容器

最新推荐文章于 2024-05-19 22:14:54 发布
最新推荐文章于 2024-05-19 22:14:54 发布
阅读量125 收藏
点赞数 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容器即是将运用最广的一些数据结构实现出来（如下图所示)。未来，在每五
序列式容器详解-stl源码剖析笔记
weixin_42853463的博客
06-24 363
public；//表示目前使用空间的头 iterator finish;//表示目前使用空间的尾 iterator end_of_storage;//表示目前可用空间的尾 void insert_aux(iterator position , const T & x);} public ://全局函数 deallocate();//vector的成员函数 } reference front() {
C++基础与深度解析 | 序列容器 | 关联容器 | 适配器与生成器
最新发布
zwcslj的博客
05-19 968
C++ 标准库提供了多种容器，它们是用于存储和操作数据集合的模板类。每种容器都有其特定的用途和特点，以及支持的基本操作。
4. 序列式容器
hello_dear_you的博客
12-28 704
STL的序列式容器学习
序列容器
lcf枫的博客
10-09 400
序列容器 (Squence containers) 容器：容纳器物的场所。STL里面的容器自然指的是容纳对象的场所了。 上图为STL内容器的分类，两大类。序列式容器和关联式容器。 上面有递进的图表格式，表示的是包含的关系。比如heap的底层实现是vector。而priority-queue则依托于heap。stack，queue内含了deque。源码就是转调的关系，是adapte
关联式容器序列式容器对比
12-21
这些容器不像序列式容器（如vector、list）那样有明显的头部和尾部，也不提供push_back、push_front、pop_back、pop_front等操作。相反，关联式容器主要提供了对元素基于键值的快速查找、插入和删除功能，这得益于...
STL关联容器入门
02-10
STL关联容器入门
STL常用容器1
08-03
在本文中，我们将重点讨论STL中的容器，特别是序列式容器和关联式容器。 1. 序列式容器： 序列式容器是一类按照元素插入顺序存储的容器，包括vector、queue、deque、priority_queue、list和stack。这些容器有着...
STL -容器,string容器
08-26
STL容器可以分为两大类：序列式容器和关联式容器。 序列式容器的特点是强调值的排序，每个元素均有固定的位置。常见的序列式容器有vector、list、deque等。 关联式容器的特点是无需强调元素的物理顺序，各元素之间...
关于STL中list容器的一些总结
12-26
list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的...
(二) 序列容器
qq_23123181的博客
01-29 1553
1、序列式容器是什么？ 序列容器以线性序列的方式存储元素。它没有对元素进行排序，元素的顺序和存储它们的顺序相同。 array<T,N>(数组容器)是一个长度固定的序列，有N个T类型的对象，不能增加或删除元素 vector<T>(向量容器)是一个长度可变的序列，用来存放T类型的对象。必要时，可以自动增加容量，但只能在序列的末尾高效地增加或删除元素。 deque<T>（双向队列容器）是一个长度可变的，可以自动增长的序列，在序列的两端都不能高效地增加或删除元素。 li
3.1 序列式容器-vector
weixin_44477424的博客
03-02 1030
C++本身提供了一个序列容器array数组，STL中新增了一个vector，被称为动态数组。它与array的区别是它提供了动态空间大小。
STL容器
Edward2022的博客
01-28 578
C++之STL容器
C++ STL序列式容器（详解）
qq_25218501的博客
08-18 739
尽管不同容器对应着不同类别的迭代器，但这些迭代器有着较为统一的定义方式，具体分为 4 种，如表 1 所示。迭代器定义方式具体格式正向迭代器容器类名::iterator 迭代器名;常量正向迭代器容器类名::const_iterator 迭代器名;反向迭代器容器类名::reverse_iterator 迭代器名;常量反向迭代器容器类名::const_reverse_iterator 迭代器名;
【STL五】序列容器——deque容器
junxuezheng的博客
03-26 465
deque 是 double-ended queue 的缩写，又称双端队列容器。deque 容器也擅长在序列尾部添加或删除元素（时间复杂度为O(1)），而不擅长在序列中间添加或删除元素。
c++ STL中的五种序列式容器
figting
09-18 553
c++ STL中的五种序列式容器 序列式容器 序列容器，即以线性排列（类似普通数组的存储方式）来存储某一指定类型（例如 int、double 等）的数据，需要特殊说明的是，该类容器并不会自动对存储的元素按照值的大小进行排序。 序列容器大致包含以下几类容器： array<T,N>（数组容器）：表示可以存储 N 个 T 类型的元素，是 C++ 本身提供的一种容器。此类容器一旦建立，其长度就是固定不变的，这意味着不能增加或删除元素，只能改变某个元素的值； vector（向量容器）：用来
序列式容器和关联式容器
05-27
序列式容器和关联式容器是STL中的两种不同类型的容器。 序列式容器是按照元素在容器中的位置存储和访问元素的。常见的序列式容器包括vector、deque、list、forward_list等。 关联式容器是根据元素的键来存储和访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值