Day11_18:STL容器
STL容器
1.近容器
string 字符串
int arr[] 数组
2.顺序容器（模板）
vector list deque
3.容器适配器
stack queue
4.关联容器
set 集合，数据有序，不允许重复，去重，底层是红黑树，增删改查时间快
map 映射表，按照key有序，底层实现红黑树，不允许重复
multiset 可以有重复元素，红黑树里面存储的是节点数组
multimap 允许键重复
string和关联容器有find函数，顺序容器没有find函数
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s("ppppp");
string s1(s);
for (int i = 0; i < 10; i++)//插入数据初始化
{
s.push_back('a' + i);//尾插
}
s.pop_back();//尾删
for (int i = 0; i < s.size(); i++)//遍历，size是返回当前长度
{
if (s[i]== 'b')
{
s[i] = 'y';
}
cout << s[i] << " ";
}
cout << endl;
cout << typeid(s.c_str()).name() << endl;//获取到char*类型的指针
//cin >> s;//重载输入运算符，所以可以直接输入
//cout << s << endl;//重载输出运算符，直接输出
string::iterator it = s.begin();//string
for (; it != s.end(); it++)
{
//用迭代器进行插入
if (*it == 'a')
{
it = s.insert(it, 'm');
cout << *it << " ";
it++;
}
cout << *it << " ";//用迭代器进行遍历
}
cout << endl;
return 0;
}
1.string迭代器
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s("ppppp");
string s1(s);
string s2(s1.begin(), s1.end());//可以使用迭代器区间进行构造
cout << s2 << endl;
for (int i = 0; i < 10; i++)//插入数据初始化
{
s.push_back('a' + i);//尾插
}
s.pop_back();//尾删
for (int i = 0; i < s.size(); i++)//遍历，size是返回当前长度
{
if (s[i]== 'b')
{
s[i] = 'y';
}
cout << s[i] << " ";
}
cout << endl;
cout << typeid(s.c_str()).name() << endl;//获取到char*类型的指针
//cin >> s;//重载输入运算符，所以可以直接输入
//cout << s << endl;//重载输出运算符，直接输出
string::iterator it = s.begin();//string
for (; it != s.end(); it++)
{
//用迭代器进行插入
if (*it == 'a')
{
/*it = s.insert(it, 'm');
cout << *it << " ";
it++;*///插入
it = s.erase(it);
}
cout << *it << " ";//用迭代器进行遍历
}
cout << endl;
s.back();
s.front();
s.empty();
int sit = s.find('m');//查找元素，找到元素返回下标，没找到返回-1
cout << sit << endl;
//s.clear();//清除所有元素
char err[10] = { "abcdefg" };
char* p = err;
s.copy(p, 4);//拷贝,从对象拷贝到指针
cout << err << endl;
s.reserve();//扩容
s.swap(s1);//交换两个容器数据
return 0;
}
2.vector容器
通过统一的方式进行容器内部数据的访问
，泛型算法一般采用迭代器
#include<iostream>
#include<string>
#include<vector>//一维数组，按照1.5倍数扩容
#include<list>//链表
#include<deque>//二维数组，实际上为队列
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
vector<int>v;
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
v.pop_back();
cout << v.back() << endl;//输出最后一个元素的数值
cout << v.front() << endl;//输出第一个数据
cout << v.size() << endl;//当前数据长度
cout << v.max_size() << endl;//当前内存容纳大小
v.swap(v1);//交换两个容器数据
v.clear();//清除
v.empty();//判断是否为空
v.resize(10);
v.reserve(10);//扩容
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
vector<int>::iterator it = v1.begin();
for (; it != v1.end(); it++)
{
cout << *it << " ";
}
show_con(v1);
return 0;
}
#include<list>//链表
#include<deque>//二维数组，实际上为队列
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
vector<int>v;
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
v.pop_back();
cout << v.back() << endl;//输出最后一个元素的数值
cout << v.front() << endl;//输出第一个数据
cout << v.size() << endl;//当前数据长度
cout << v.max_size() << endl;//当前内存容纳大小
v.swap(v1);//交换两个容器数据
v.clear();//清除
v.empty();//判断是否为空
v.resize(10);
v.reserve(10);//扩容
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
//通过迭代器实现增删改查
vector<int>::iterator it = v1.begin();
for (; it != v1.end(); it++)
{
if (*it == 5)
{
//v1.insert(it, 999);插入
//it++;
//*it = 999;修改
//it = v1.erase(it);删除
}
cout << *it << " ";
}
cout << endl;
show_con(v1);
string s1("sssss");
show_con(s1);
copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));//函数模板，泛型算法（起始值，末尾值，输出流）
return 0;
}
多个容器嵌套可以形成多维数组
3.list链表
#include<iostream>
#include<string>
#include<vector>//一维数组，按照1.5倍数扩容
#include<list>//链表
#include<deque>//二维数组，实际上为队列
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
//链表
list<int>L;
for (int i = 0; i < 10; i++)
{
L.push_back(i);
}
show_con(L);
vector<int>v1(L.begin(), L.end());//通过链表迭代器区间初始化vector，构造新容器，存储数据类型必须一致
show_con(v1);
L.push_front(3);//链表独有成员方法
L.pop_front();//链表独有成员方法
L.resize(20);
L.reverse();//链表独有成员方法-逆置
return 0;
}
3.deque双端队列
从中间进行插入删除操作
4.容器适配器——stack&queue
#include<iostream>
#include<string>
#include<vector>//一维数组，按照1.5倍数扩容
#include<list>//链表
#include<deque>//二维数组，实际上为队列
#include<stack>
#include<queue>
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
//stack-deque
stack<int>s;
for (int i = 0; i < 10; i++)
{
s.push(i);//插入
}
s.pop();//删除
s.top();//获取栈顶元素
s.empty();//判空
//s.swap();//交换
//queue-deque
queue<int>q;
for (int i = 0; i < 10; i++)
{
q.push(i);//插入
}
q.pop();
q.front();//获取队列先出的那个元素
q.back();//获取队尾
q.size();
q.empty();
//q.swap();
//优先级队列-会给队列中元素排序
priority_queue<int>a;
return 0;
}
5.关联容器——set&map
关联容器——set（会自动给元素排序，有序，可以自动去重）
set：数据有序，底层是红黑树，所以会自动排序，不允许重复，可以自动去重，增删改查时间非常快
#include<iostream>
#include<string>
#include<vector>//一维数组，按照1.5倍数扩容
#include<list>//链表
#include<deque>//二维数组，实际上为队列
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
//关联容器——set（会自动给元素排序，有序，可以自动去重）
set<int>s;
s.insert(12);
s.insert(23);
s.insert(34);
s.insert(45);
s.insert(56);
show_con(s);
set<int>::iterator it = s.find(78);//find返回值是迭代器
if (it != s.end())
{
cout << *it << endl;
}
else
{
cout << "Don't find" << endl;
}
s.clear();//全部删除元素
cout << s.count(12) << endl;//记录某个元素在容器中有几个，不允许数据重复
s.empty();
s.size();
//s.swap();
return 0;
}
#include<iostream>
#include<string>
#include<vector>//一维数组，按照1.5倍数扩容
#include<list>//链表
#include<deque>//二维数组，实际上为队列
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
//关联容器——set（会自动给元素排序，有序，可以自动去重）
set<int>s;
s.insert(12);
s.insert(23);
s.insert(34);
s.insert(45);
s.insert(56);
show_con(s);
set<int>::iterator it = s.find(78);//find返回值是迭代器
if (it != s.end())
{
cout << *it << endl;
}
else
{
cout << "Don't find" << endl;
}
s.clear();//全部删除元素
cout << s.count(12) << endl;//记录某个元素在容器中有几个，不允许数据重复
s.empty();
s.size();
//s.swap();
/*vector<int>v;
return min(set<int>(v.begin(), v.end()).size(), v.size() / 2);*/
multiset<int>ms;//可以存放不重复的数据
ms.insert(12);
ms.insert(23);
ms.insert(34);
ms.insert(45);
ms.insert(56);
ms.insert(56);
show_con(ms);
multiset<int>::iterator it1 = ms.find(56);//find返回值是迭代器
if (it1 != ms.end())
{
for (int i = 0; i < ms.count(56); i++)
{
cout << *it1 << endl;
it1++;
}
}
else
{
cout << "This element was not find" << endl;
}
return 0;
}
#include<iostream>
#include<string>
#include<vector>//一维数组，按照1.5倍数扩容
#include<list>//链表
#include<deque>//二维数组，实际上为队列
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
template<typename CON>
void show_con(CON& con)
{
typename CON::iterator it = con.begin();
for (int i = 0; it != con.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
//map——映射表，数据按Key有序，底层实现红黑树，不允许重复
map<int, string>mm;
mm.insert(make_pair(1, "aaaa"));
mm.insert(make_pair(2, "bbbb"));
mm.insert(make_pair(3, "cccc"));
mm.insert(make_pair(4, "dddd"));//函数模板返回的是一个类模板对象
mm.insert(pair<int, string>(5, "eeee"));//两种写法都可以
map<int, string>::iterator it = mm.begin();
for (; it != mm.end(); it++)
{
cout << it->first << "->";
cout << it->second << endl;
}
map<int, string>::iterator it1 = mm.find(5);
if (it1 != mm.end())
{
cout << it1->first << "->";
cout << it1->second << endl;
}
mm.empty();
mm.clear();
mm.erase(5);
//mm.swap();
mm.count(5);
multimap<int, string> mmm(mm.begin(), mm.end());
mmm.insert(make_pair(1, "aaaa"));
mmm.insert(make_pair(2, "bbbb"));
mmm.insert(make_pair(3, "cccc"));
mmm.insert(make_pair(4, "dddd"));//函数模板返回的是一个类模板对象
mmm.insert(pair<int, string>(5, "eeee"));//两种写法都可以
map<int, string>::iterator it2 = mm.find(5);
if (it2 != mmm.end())
{
cout << it1->first << "->";
cout << it1->second << endl;
}
show_con(mm);
return 0;
}
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
