一些常用STL容器总结-CFANZ编程社区

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三大组件，容器、算法和迭代器