STL【三】
1、list容器
💖基本概念：
- 将数据进行链式存储
- 链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
- 链表的组成：链表由一系列节点组成
- 结点组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
- STL中的链表是一个双向循环链表
- 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。
💖优点：
- 链表可以对任意位置进行快速插入和删除元素。
- 采用动态存储分配，不会造成内存浪费和溢出
💖缺点：
- 链表灵活，但是空间和时间消耗比较大
list有一个重要的性质，就是进行插入和删除操作的时候迭代器都是不会失效的，这在list中是不存在的。
练习代码：
#include <iostream>
#include <list>
#include <algorithm>
using namespace std;
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//构造函数练习
void test01()
{
list<int> L1;
for (int i = 0; i < 5; i++)
{
L1.push_back(i + 1);
}
printList(L1);
//按照区间构造
list<int> L2(L1.begin(), L1.end());
printList(L2);
//拷贝构造
list<int>L3(L2);
printList(L3);
//10个100
list<int>L4(10, 1000);
printList(L4);
}
//赋值和交换操作
void test02()
{
//赋值
list<int> L1;
for (int i = 0; i < 4; i++)
{
L1.push_back(i + 1);
}
printList(L1);
list<int>L2 = L1;//operator=
printList(L1);
list<int>L3;
L3.assign(L2.begin(), L2.end());
printList(L3);
list<int> L4;
L4.assign(10, 100);
printList(L4);
//交换
cout << "交换前：" << endl;
printList(L1);
printList(L4);
cout << "交换后：" << endl;
L1.swap(L4);
printList(L1);
printList(L4);
}
//大小操作
void test03()
{
list<int> L1;
for (int i = 0; i < 4; i++)
{
L1.push_back(i + 1);
}
printList(L1);
if (L1.empty())
{
cout << "L1 is null" << endl;
}
else
{
cout << "L1 is not null" << endl;
cout << "元素个数：" << L1.size() << endl;
}
//重新指定大小
L1.resize(10);//指定过大
printList(L1);
L1.resize(2);//指定过小
printList(L1);
}
//插入删除操作
void test04()
{
list<int> L1;
for (int i = 0; i < 4; i++)
{
L1.push_back(i + 1);//尾部插入
}
L1.push_front(10);//头部插入
printList(L1);
L1.pop_back();//尾部删除
printList(L1);
L1.pop_front();//头部删除
printList(L1);
//insert
L1.insert(L1.begin(), 1000);//第一个参数的迭代器，第二个是要插入的值
printList(L1);
//erase
L1.erase(L1.begin());//参数是迭代器
printList(L1);
//remove
L1.remove(2);//按照值进行删除（删除容器中所有匹配的值）
printList(L1);
L1.clear();//清空容器
printList(L1);
}
//数据存取
void test05()
{
//list不可以用[]和at的方式访问数据，因为它支持双向迭代器(it++;it--;)，不支持随机访问迭代器(it+1;it-1;)
list<int> L1;
for (int i = 0; i < 4; i++)
{
L1.push_back(i + 1);//尾部插入
}
printList(L1);
cout << "第一个元素：" << L1.front() << endl;
cout << "最后一个元素：" << L1.back() << endl;
}
bool myCompare(int v1,int v2)
{
//降序 第一个数大于第二个数
return v1 > v2;
}
//list的反转和排序操作
void test06()
{
list<int> L1;
for (int i = 0; i < 4; i++)
{
L1.push_back(i + 1);//尾部插入
}
L1.push_front(5);
printList(L1);
//反转
L1.reverse();
printList(L1);
//排序
//所有不支持随机访问迭代器的容器，不可以使用标准排序算法
//不支持随机访问迭代器的容器内部会提供对应的算法
L1.sort();//默认排序规则：从小到达
printList(L1);
//降序排序
L1.sort(myCompare);//用一个指定函数或者仿函数作为参数（仿函数后面笔记介绍）
printList(L1);
}
int main()
{
//test01();
//test02();
//test03();
//test04();
//test05();
test06();
return 0;
}
2、list容器案例----排序
💖案例描述：
- 将Person自定义数据类型进行排序，Person中属性有姓名、年龄和身高
- 按照年龄进行升序排序，如果年龄相同则按身高进行降序排序
案例代码如下：
#include <iostream>
#include <list>
#include <string>
#include <algorithm>
using namespace std;
class Person
{
public:
Person(string name, int age, int heigh)
{
this->m_name = name;
this->m_age = age;
this->m_heigh = heigh;
}
string m_name;//姓名
int m_age;//年龄
int m_heigh;//身高
};
//指定排序规则
bool myCompare(Person& p1, Person& p2)
{
//按照年龄做升序
if (p1.m_age == p2.m_age)
{
//年龄相同按照身高进行降序
return p1.m_heigh > p2.m_heigh;
}
else
{
return p1.m_age < p2.m_age;
}
}
void test01()
{
list<Person> L;//创建容器
Person p1("liubei", 35, 173);
Person p2("zhangfei", 35, 175);
Person p3("guanyu", 39, 186);
Person p4("caocao", 38, 166);
Person p5("jinke", 31, 177);
Person p6("daiqi", 31, 177);
//插入数据
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
L.push_back(p6);
//打印
cout << "排序前：" << endl;
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "name:" << (*it).m_name << " " << "age:" << (*it).m_age << " " << "heigh:" << (*it).m_heigh << endl;
}
cout << "排序后：" << endl;
L.sort(myCompare);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "name:" << (*it).m_name << " " << "age:" << (*it).m_age << " " << "heigh:" << (*it).m_heigh << endl;
}
}
int main()
{
test01();
return 0;
}
3、set/multiset容器
💖set基本概念：
- 所有元素都会在插入时自动被排序
- set/multiset属于关联式容器，底层结构是用二叉树实现
💖set和multiset的区别：
- set中不允许容器中有重复元素
- multiset中允许容器中有重复元素
练习如下：
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
//set插入时被自动排序，而且不允许插入重复元素
set<int> s1;
//插入元素只能用insert
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(30);
s1.insert(20);
printSet(s1);
//拷贝构造
set<int> s2(s1);
printSet(s2);
//赋值
set<int>s3 = s2;
printSet(s3);
}
//set的大小和交换操作
void test02()
{
//set插入时被自动排序，而且不允许插入重复元素
set<int> s1;
//插入元素只能用insert
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(30);
s1.insert(20);
printSet(s1);
if (s1.empty())
{
cout << "s1 is null" << endl;
}
else
{
cout << "s1 is not null" << endl;
cout << "大小：" << s1.size() << endl;
}
set<int> s2;
for (int i = 1; i < 5; i++)
{
s2.insert(i);
}
printSet(s2);
cout << endl;
//交换
cout << "交换前：" << endl;
printSet(s1);
printSet(s2);
s1.swap(s2);
cout << "交换后：" << endl;
printSet(s1);
printSet(s2);
}
//set的插入和删除操作
void test03()
{
set<int> s1;
for (int i = 1; i < 10; i++)
{
s1.insert(i * 10);//插入
}
printSet(s1);
//删除
s1.erase(s1.begin());//参数是迭代器
printSet(s1);
s1.erase(30);//按照值进行删除
printSet(s1);
//清空操作
s1.erase(s1.begin(), s1.end());
printSet(s1);
s1.clear();
printSet(s1);
}
//set查找和统计
void test04()
{
set<int> s1;
for (int i = 1; i < 10; i++)
{
s1.insert(i * 10);//插入
}
printSet(s1);
//查找
set<int>::iterator pos = s1.find(300);//返回一个迭代器
if (pos != s1.end())
{
cout << "找到了" << endl;
}
else
{
cout << "没有找到" << endl;
}
//统计300的个数
//统计个数的结果要么是0要么是1
int num = s1.count(300);
cout << "num:" << num << endl;
}
//set multiset的区别
void test05()
{
set<int> s;
pair<set<int>::iterator, bool> ret = s.insert(10);
if (ret.second)
{
cout << "插入数据成功！" << endl;
}
else
{
cout << "插入失败！！" << endl;
}
ret = s.insert(10);//第二次插入10失败
if (ret.second)
{
cout << "插入数据成功！" << endl;
}
else
{
cout << "插入失败！！" << endl;
}
multiset<int> ms;
ms.insert(100);
ms.insert(100);//允许插入重复数据
for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//pair对组创建,成对出现的数据可以用对组来返回两个数据
//不需要包含头文件
void test06()
{
//第一种创建方式
pair<string, int> p("tom", 20);
cout << "name:" << p.first << " " << "age:" << p.second << endl;
//第二种创建方式
pair<string, int>p2 = make_pair("jerry", 23);
cout << "name:" << p2.first << " " << "age:" << p2.second << endl;
}
//set指定排序规则
//仿函数（后面笔记详细介绍）
class MyComplare
{
public:
bool operator()(int v1, int v2) const
{
return v1 > v2;
}
};
//存放自定义数据类型的时候必须要利用仿函数指定排序规则
//set存放内置数据类型
void test07()
{
set<int> s1;//默认从小到达排序
s1.insert(30);
s1.insert(90);
s1.insert(10);
printSet(s1);
set<int, MyComplare> s2;//修改排序规则为从大到小
s2.insert(30);
s2.insert(90);
s2.insert(10);
for (set<int, MyComplare>::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
//test01();
//test02();
//test03();
//test04();
//test05();
//test06();
test07();
return 0;
}
4、map/multimap容器
💖map基本概念：
- map中所有元素都是pair
- pair中第一个元素为key，起到索引作用，第二个元素为value
- 所有元素都会根据元素的键值自动排序
💖本质：
- map/multimap属于关联式容器，底层结构也是二叉树
💖优点：
- 可以用key值快速找到value值
💖map/multimap的区别：
- map中不允许有重复的key值
- multimap中允许有重复的key值
练习代码：
#include <iostream>
#include <map>
#include <string>
using namespace std;
void printMap(map<int, int>& m)
{
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key:"<<it->first << " " <<"value:"<< it->second << " ";
}
cout << endl;
}
void test01()
{
map<int, int> m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(4, 30));
m.insert(pair<int, int>(3, 40));
printMap(m);//按照key值进行从小到大排序
map<int, int> m2(m);//拷贝构造
printMap(m2);
map<int, int> m3 = m2;//赋值
printMap(m3);
}
//map大小和交换
void test02()
{
map<int, int> m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(4, 30));
m.insert(pair<int, int>(3, 40));
printMap(m);//按照key值进行从小到大排序
if (m.empty())
{
cout << "m is null" << endl;
}
else
{
cout << "m is not null" << endl;
cout << "大小：" << m.size() << endl;
}
printMap(m);
//交换
map<int, int> m2;
m2.insert(pair<int, int>(7, 10));
m2.insert(pair<int, int>(8, 20));
m2.insert(pair<int, int>(9, 30));
m2.insert(pair<int, int>(10, 40));
cout << "交换前：" << endl;
printMap(m);
printMap(m2);
cout << "交换后：" << endl;
m.swap(m2);
printMap(m);
printMap(m2);
}
//插入和删除
void test03()
{
map<int, int> m;
//插入
m.insert(pair<int, int>(1, 10));
m.insert(make_pair(2, 20));
m.insert(map<int, int>::value_type(3, 30));//不建议使用
m[4] = 40;//不建议[]进行插入
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);//按照key进行删除
printMap(m);
m.erase(m.begin(), m.end());
printMap(m);
m.clear();//清空
printMap(m);
}
//查找和统计
void test04()
{
map<int, int> m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(4, 30));
m.insert(pair<int, int>(3, 40));
map<int,int>::iterator pos = m.find(3);
if (pos != m.end())
{
cout << "找到了元素key = " << pos->first << " " << "value:" << pos->second << endl;
}
else
{
cout << "没有找到" << endl;
}
//统计
//map不允许插入重复的key
int ret = m.count(3);
cout << "num:" << ret << endl;
}
//map排序,，利用仿函数改变排序规则
class MyCompare
{
public:
bool operator()(int v1, int v2)const
{
//降序
return v1 > v2;
}
};
void test05()
{
map<int, int,MyCompare> m2;
m2.insert(pair<int, int>(1, 10));
m2.insert(pair<int, int>(2, 20));
m2.insert(pair<int, int>(4, 30));
m2.insert(pair<int, int>(3, 40));
for (map<int, int, MyCompare>::iterator it = m2.begin(); it != m2.end();it++)
{
cout << it->first << " " << it->second << " ";
}
cout << endl;
}
int main()
{
//test01();
//test02();
//test03();
//test04();
test05();
return 0;
}
👀👀👀
4888
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
