C++STL（三）

stack栈容器

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

stack没有迭代器

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

#include <iostream>
#include <stack>
using namespace std;

void test01()
{
	stack<int>s;
	s.push(1);
	s.push(2);
	s.push(3);

	//打印数据
	while (s.size() != 0)
	{
		cout << "栈顶为：" << s.top() << endl;
		s.pop();
	}
}

int main()
{
	test01();
	return 0;
}

queue队容器

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

 queue没有迭代器

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

 API操作和stack栈容器基本相同

list容器

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

• 采用动态存储分配，不会造成内存浪费和溢出
• 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
• 链表灵活，但是空间和时间额外耗费较大

 list容器的迭代器 

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

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至List元素的删除，也只有被删除的那个元素的迭代器失效，其他迭代器不受任何影响。

list容器的数据结构

list容器不仅是一个双向链表,而且还是一个循环的双向链表。

#include <iostream>
#include <string>
#include <list>
using namespace std;

void printList(list<int> &l);

//list是双向循环链表
void test01() 
{
	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;
		}
	}
}

void test02() 
{
	list<int>L(10,10);
	list<int>L2(L.begin(),L.end());

	printList(L);
	printList(L2);
}

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

void test03()
{
	list<int> L;
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_back(40);
	L.push_back(50);
	printList(L);

	//删除
	L.pop_front();  //头删
	L.pop_back(); //尾删

	//remove(elem)  删除容器中所有与elem值匹配的元素
}

bool myCompare(int v1,int v2)
{
	return v1 > v2;
}

//list反转排序
//reverse（） 反转链表，比如list包含1,3,5元素，运行此方法就包含5,3,1
void test04()
{
	list<int> L;
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_back(40);
	printList(L);

	L.reverse();
	printList(L);

	//sort(L.begin(),L.end()) 不能使用 所有不支持随机访问的迭代器，不可以用系统提供的算法
	//检查是否支持随机访问
	//list<int>::iterator itBegin;
	//itBegin += 1;  //报错，不支持随机访问

	//如果不支持用系统提供算法，那么这个类内部会提供
	L.sort(); //从小到大排序
	L.sort(myCompare); //从大到小排序
	printList(L);
}

//自定义数据类型
class Person 
{
public:
	Person(string name,int age):m_Name(name),m_Age(age) {}

	//重载==让remove可以删除自定义的person类型
	bool operator==(const Person &p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		return false;
	}

public:
	string m_Name;
	int m_Age;
};

bool myComparePerson(Person p1,Person p2)
{
	return p1.m_Age > p2.m_Age;
}

void test05()
{
	list<Person> L;

	Person p1("亚瑟",15);
	Person p2("张三", 16);
	Person p3("李四", 17);
	Person p4("王五", 18);

	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);

	//按年龄降序输出
	//对于自定义数据类型，必须要指定排序规则
	L.sort(myComparePerson);
	//printList(L); 

	//删除李四
	L.remove(p3);

	for (list<Person>::iterator it = L.begin();it != L.end();it++)
	{
		cout << "姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
	}
}

int main()
{
	test05();
	return 0;
}