stack 容器
只有栈顶元素才可以被外界使用，不允许有遍历行为
-
构造函数
stack<T> stk; stack(const stack &stk); -
赋值操作
stack& operator=(const stack &stk); -
数据存取
push(elem); pop(); top(); -
大小操作
empty(); size();
queue 容器
-
构造函数
queue<T> que; queue(const queue &stk); -
赋值操作
queue& operator=(const queue &que); -
数据存取
push(elem); pop(); back(); front(); -
大小操作
empty(); size();
set / multiset 容器
本质： 属于关联式容器，底层结构用二叉树实现
区别： set不允许容器中有重复的元素， multiset允许容器中有重复的元素
-
构造和赋值操作
set<T> st; set(const set& st); set& operator=(const set &st); 插入数据只有insert方式,并且所有元素插入时被自动排序。 -
大小和交换
size(); empty(); swap(); -
插入和删除
insert(elem); clear(); erase(pos); erase(beg, end); erase(elem); -
查找和统计
find(key);//如果元素存在返回该元素的位置，否则返回容器结束的位置 count(key);//统计key元素个数 -
pari 使用
创建方式：
//利用对组可以返回两个数据
pair<type, type> p(value1, value2);
pair<type, type> p = make_pair(value1, value2);
//第一种
pair<string, int>p("Tom", 20);
//第二种
pair<string, int>p2 = make_pair("Jerry", 30);
- set 容器排序
技术点：利用仿函数，改变排序规则
示例一：
1. set存放内置数据类型
class MyCompare
{
public:
bool operator()(int v1, int v2) const //返回类型是bool型，重载的符号是（）。仿函数
{
return v1 > v2;
}
};
void test01()
{
set<int, MyCompare> s1;
s1.insert(10);
s1.insert(20);
s1.insert(30);
s1.insert(60);
s1.insert(50);
s1.insert(90);
for (set<int, MyCompare>::iterator it = s1.begin(); it != s1.end(); it++)
{
cout << *it << " ";
}
}
利用仿函数可以指定set容器的排序规则
2. set存放自定义数据类型
class Person
{
public:
Person(string name, int age, int height)
{
this->m_Name = name;
this->m_Age = age;
this->m_Height = height;
}
public:
string m_Name;
int m_Age;
int m_Height;
};
class MyCompare
{
public:
bool operator()(const Person& v1, const Person& v2) const //返回类型是bool型，重载的符号是（）。仿函数
{
return v1.m_Age > v2.m_Age;
}
};
void test01()
{
set<Person, MyCompare> s1;//自定义数据类型要自行制定排序规则
Person p1("堂本光一", 10, 170);
Person p2("堂本刚", 11, 171);
Person p3("谢霆锋", 12, 175);
Person p4("肖战", 26, 170);
Person p5("王一博", 20,170);
Person p6("丁真", 18, 170);
s1.insert(p1);
s1.insert(p2);
s1.insert(p3);
s1.insert(p4);
s1.insert(p5);
s1.insert(p6);
for (set<Person, MyCompare>::iterator it = s1.begin(); it != s1.end(); it++)
{
cout << it->m_Name << " " << it->m_Age << " " << it->m_Height << endl;
}
}
map / multimap 容器
简介： map中所有元素都是pair，pair中第一个元素为key，起到索引作用，第二个元素为value(实值)，所有元素都会根据键值自动排序，可以根据键值快速找到value值
本质： 属于关联式容器，底层结构用二叉树实现
区别： map不允许容器中有重复的key元素， multimap允许容器中有重复的key元素
-
构造和赋值操作
map<T1, T2> mp; map(const map &mp); map& operator=(const map &mp); map<int, int> m; m.insert(pair<int, int>(1, 10)); cout << (*it).first << (*it).second << endl; -
大小和操作
size(); empty(); swap(); -
插入和删除
insert(elem); clear(); erase(pos); erase(beg, end); erase(key); map<int, int> m; m.insert(make_pair(2, 20)); -
查找和统计
find(key); //查找key是否存在，若存在返回该键的元素的迭代器，若不存在，返回map.end() count(key); -
map容器排序
-
利用仿函数改变排序规则
同其它容器
map<int, int, MyCompare> m;
list 容器
将数据进行链式存储，STL中的链表是一个双循环链表，遍历速度没有数组快，灵活但占用空间大
-
函数原型
list<T> list; list(beg, end); list(n, elem); list(const list& list);//拷贝构造函数
list 赋值和交换
-
函数原型
assign(beg, end); assign(n, elem); list& operator=(const list &list); swap(list);
list 大小操作
-
函数原型
size(); empty(); resize(num); resize(num, elem);
list 大小操作
-
函数原型
push_back(elem); pop_back(); push_front(elem); pop_front(); insert(pos, elem); // 必须提供迭代器 insert(pos, n, elem); insert(pos, beg, end); clear(); erase(beg, end); 必须提供迭代器 erase(pos); remove(elem);
list 数据存取
-
函数原型
front(); //返回第一个元素 back(); //返回最后一个元素
迭代器不支持随机访问，只能递增或者递减
list 反转和排序
reverse(); //反转链表
sort(); //链表排序
如何写降序函数
bool myCompare(int v1, int v2)
{
return v1 > v2;
}
L1.sort(myCompare);//降序排列
list 排序案例
#include <iostream>
using namespace std;
#include <deque>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <list>
class Person
{
public:
Person(string name, int age, int height)
{
this->m_Name = name;
this->m_Age = age;
this->m_Height = height;
}
public:
string m_Name;
int m_Age;
int m_Height;
};
//指定排序规则
bool comparePerson(Person& p1, Person& p2)
{
//按照年龄升序
if (p1.m_Age == p2.m_Age)
{
return p1.m_Height > p2.m_Height;
}
return p1.m_Age < p2.m_Age;
}
void test01()
{
list<Person> L;
Person p1("刘备", 35, 175);
Person p2("曹操", 45, 180);
Person p3("孙权", 40, 170);
Person p4("赵云", 26, 190);
Person p5("张飞", 35, 160);
Person p6("关羽", 35, 200);
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
L.push_back(p6);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << it->m_Age << " " << it->m_Name << " " << it->m_Height << endl;
}
cout << "排序后： " << endl;
L.sort(comparePerson);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << it->m_Age << " " << it->m_Name << " " << it->m_Height << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
deque 容器
deque是双端数组，可以对头端进行删除操作
deque与vector区别：
1.vector单端数组，对于头部的插入效率较低，数据量越大，效率越低
2.deque对头部的插入速度比vector快
3.vector访问元素时的速度会比deque快，这和两者内部实现有关
deque内部工作原理：deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据，中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间，因此访问数据会慢一些。
- deque构造函数
函数原型：
deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg,end]区间中的元素拷贝给本身
deque(n, elem);//构造函数将n个elem拷贝给本身
deque(const deque &deq);//拷贝构造函数
示例：
void myprint(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
const 限制容器为只读不可修改，于是it的类型也应该是const类型，由const性质可得。
- deque赋值操作
函数原型：
deque& operator=(const deque& deq);//重载等号操作符
assign(beg, end);//将[beg，end]区间中的数据拷贝赋值给本身
assign(n, elem);//将n个elem拷贝赋值给本身
- deque大小操作
函数原型：
说明：类似vector，但没有容量限制，因此没有capacity函数
empty();
size();
resize(num);
resize(num, elem);
- deque插入和删除
函数原型：
push_back(elem);
push_front(elem);
pop_back();//删除最后一个数据
pop_front();//删除第一个数据
insert(pos, elem); //在pos位置插入elem，返回新数据的位置
insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值
insert(pos, beg, end); //插入区间数据，无返回值
clear();
earse(beg, end);//删除区间数据，返回下一个数据的位置
earse(pos); //删除pos位置的数据，返回下一个数据的位置
- deque数据存取
函数原型：
at(int idx);
operator[];
front();
back();
- deque排序操作
函数原型：
sort(itrator beg, iterator end);//对区间内的数据进行排序,升序
所有算法必须包含的头文件 <algorithm>,STL三大组件，容器、算法和迭代器
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
