STL 2

STL 详解2

1.stack容器

栈容器是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历行为。

有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.

1.数据结构：连续的存储空间，只有一个出口，先进后出特性

2.迭代器:没有迭代器

3.常用的api:

​ 1.构造函数

stack<T> stkT;//stack采用模板类实现， stack对象的默认构造形式： 
stack(const stack &stk);//拷贝构造函数

​ 2.赋值

stack&operator=(const stack &stk);//重载等号操作符

​ 3.数据存取

push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素

​ 3.大小操作

empty();//判断堆栈是否为空
size();//返回堆栈的大小

4.打印方法

class Maker
{
public:
	Maker(string name, int age)
	{
		this->name = name;
		this->age = age;
	}
public:
	string name;
	int age;
};
//存储对象
void test02()
{
	stack<Maker> s;
	s.push(Maker("aaa", 18));
	s.push(Maker("bbb", 19));
	s.push(Maker("ccc", 20));

	while (!s.empty())
	{
		cout << "Name:" << s.top().name << " Age:" << s.top().age << endl;
		s.pop();
	}
	
}

2.queue容器

1.数据结构：连续的存储空间，有两个口，一个是进入数据，一个是出数据，有先进先出的特性

Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素。

Queue所有元素的进出都必须符合”先进先出”的条件，只有queue的顶端元素，才有机会被外界取用。Queue不提供遍历功能，也不提供迭代器。

2.迭代器：没有迭代器

3.常用的api:

​ 1.构造函queue queT;//queue采用模板类实现，queue对象的默认构造形式：

queue(const queue &que);//拷贝构造函数数

queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：
queue(const queue &que);//拷贝构造函数

​ 2.存取、插入和删除操作

push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素

​ 3.赋值

queue&operator=(const queue &que);//重载等号操作符

​ 4.大小操作

empty();//判断队列是否为空
size();//返回队列的大小

5.打印操作

class Maker
{
public:
	Maker(string name, int age)
	{
		this->name = name;
		this->age = age;
	}
public:
	string name;
	int age;
};

void test02()
{
	queue<Maker *> q;
	q.push(new Maker("aaa", 18));
	q.push(new Maker("bbb", 19));
	q.push(new Maker("ccc", 20));

	while (!q.empty())
	{
		Maker *m = q.front();
		cout << m->name << " " << m->age << endl;
		q.pop();
		delete m;

	}

}

3.list容器

1.数据结构：双向循环链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。

List和vector是两个最常被使用的容器。

List容器是一个双向链表。

2.迭代器：双向迭代器

由于list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators.

*List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。*

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<list>
usingnamespace std;

int main(){

	list<int> myList;
	for(int i =0; i <10; i ++){
		myList.push_back(i);
	}

	list<int>::_Nodeptr node =  myList._Myhead->_Next;

	for(int i =0; i < myList._Mysize *2;i++){
		cout <<"Node:"<< node->_Myval << endl;
		node = node->_Next;
		if(node == myList._Myhead){
			node = node->_Next;
		}
	}

	system("pause");
	return EXIT_SUCCESS;

void printList(const list<int> &mylist)
{
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}

3.常用的api:

​ 1.构造

list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。

​ 2.数据元素的插入和删除

push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。

bool myfunc(int val)
{
	return val > 300;
}
//删除大于300
mylist.remove_if(myfunc);
	printList(mylist);

​

3.大小操作

size();//返回容器中元素的个数
empty();//判断容器是否为空
//为0就是不为空
resize(num);//重新指定容器的长度为num，
若容器变长，则以默认值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
若容器变长，则以elem值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。

​ 4.赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list&operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。

​ 5.数据的存取

front();//返回第一个元素。
back();//返回最后一个元素。

​ 6.反转和排序

reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); //list排序

4.注意：list容器不能使用常用的sort,只能使用自己的sort

bool myfunc2(int v1, int v2)
{
	return v1 > v2;
}
void test051()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 10);
	}

	printList(mylist);

	mylist.reverse();

	printList(mylist);

	//注意：list容器不能使用sort算法
	//sort(mylist.begin(), mylist.end());
	mylist.sort();

	printList(mylist);

	mylist.sort(myfunc2);
	printList(mylist);
}

4.对组pair

对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。

类模板：template <class T1, class T2> struct pair.

//第一种方法创建一个对组
pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl; //访问pair第一个值
cout << pair1.second << endl;//访问pair第二个值
//第二种
pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
//pair=赋值
pair<string, int> pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;

5.set /multiset容器

1.set容器是关联式容器，容器自身有规则，通过键值排序，set容器中的元素是键值也是实值

Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值。

2.set容器和multiset容器的区别是multiset允许有相同的元素

multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。

3.数据结构：平衡二叉树

4.迭代器：双向迭代器

我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator.

5.常用的api:

​ 1.构造

set<T> st;//set默认构造函数：
mulitset<T> mst; //multiset默认构造函数: 
set(const set &st);//拷贝构造函数

​ 2.赋值

set&operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器

​ 3.大小

size();//返回容器中元素的数目
empty();//判断容器是否为空

​ 4.插入和删除

insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。

​ 5.查找操作

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
1.	count(key);//查找键key的元素个数
2.	lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
3.	upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

6.改变规则：默认是从小到大，改变规则，加入谓词到<>第二个参数中

7.注意：

​ 1.set容器插入相同元素时，不会报错，但是不插入数据

​ 2.set容器存储对象时，需要告诉set容器的规则

5.map

1.map/multimap也是关联式容器，容器自身有规则，通过键值排序，map容器中的元素是对组，对组的第一个元素是键值，不能改变，第二个元素是实值，可以改变

2.数据结构：平衡二叉树

3.迭代器：双向迭代器

4.map容器和multimap容器的区别是multimap允许有相同的元素

5.常用的api:

​ 1.构造

map<T1, T2> mapTT;//map默认构造函数: 
map(const map &mp);//拷贝构造函数

​ 2.赋值

map&operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器

​ 3.大小

size();//返回容器中元素的数目
empty();//判断容器是否为空

​ 4.查找

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end();
count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。	
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器

​ 5.插入

map.insert(...); //往容器插入元素，返回pair<iterator,bool>
map<int, string> mapStu;
// 第一种 通过pair的方式插入对象
mapStu.insert(pair<int, string>(3, "小张"));
// 第二种 通过pair的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过value_type的方式插入对象
mapStu.insert(map<int, string>::value_type(1, "小李"));
// 第四种 通过数组的方式插入值
mapStu[3] = "小刘";
mapStu[5] = "小王";

​ 6.删除

clear();//删除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中key为keyElem的对组。