STL——stack容器、queue容器、list容器

stack容器

stack容器——基本概念

就是栈
栈不允许有遍历行为
是先进后出的数据结构

stack容器——常用接口

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//栈stack容器

void test01()
{
	//特点:符合先进后出数据结构
	stack<int>s;

	//入栈
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);

	cout << "栈的大小:" << s.size() << endl;
	//只有栈不为空，查看栈顶，并且执行出栈操作
	while (!s.empty())
	{
		//查看栈顶元素
		cout << "栈顶元素为:" << s.top() << endl;
		//出栈
		s.pop();
	}
	cout << "栈的大小:" << s.size() << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

queue容器

queue容器——基本概念

是先进先出的数据结构

**队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为
队列中进数据称为—入队push
队列中出数据称为—出队pop
**

queue容器——常用接口

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
using namespace std;

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

	string m_Name;
	int m_Age;
};

//队列 Queue
void test01()
{
	//创建队列
	queue<Person>q;

	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 30);
	Person p3("猪八戒", 30);
	Person p4("沙僧", 30);

	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	cout << "队列的大小为:" << q.size() << endl;

	//判断只要队列不为空，查看对头，查看队尾，出队
	while (!q.empty())
	{
		//查看对头元素
		cout << "对头元素 --- 姓名:" << q.front().m_Name << " 对头元素 --- 年龄:" << q.front().m_Age << endl;
		//查看对尾元素 
		cout << "对尾元素 --- 姓名:" << q.back().m_Name << " 对尾元素 --- 年龄:" << q.back().m_Age << endl;
		q.pop();
	}
	cout << "队列的大小为:" << q.size() << endl;
}
int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

list容器

list容器基本概念

在STL中这个链表是双向链表

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
list的优点∶
采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list的缺点:
链表灵活，但是空间(指针域)和时间(遍历)额外耗费较大
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。
list和vector是经常被使用的容器

list容器——构造函数

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printList(const list<int>&d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		//加上const防止修改代码
		//容器中的数据不可以修改了
		//*it = 100; err
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	//创建list容器
	list<int>L1;//默认构造
	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//遍历容器
	printList(L1);

	//区间方式构造
	list<int>L2(L1.begin(), L1.end());
	printList(L2);

	//拷贝构造
	list<int>L3(10, 1000);
	printList(L3);

	//n个elem
	list<int>L4(L3);
	printList(L4);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

list容器——赋值和交换

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//list容器赋值和交换
void printList(const list<int>&d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;
	
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	list<int>L2;
	L2 = L1;
	printList(L2);

	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);

	list<int>L4;
	L4.assign(10, 100);
	printList(L4);
}

//交换
void test02()
{
	list<int>L1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	list<int>L2;
	L2.assign(10, 100);
	cout << "交换前: " << endl;
	printList(L1);
	printList(L2);

	L1.swap(L2);
	cout << "交换后:" << endl;
	printList(L1);
	printList(L2);
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

List容器——大小操作

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//list容器赋值和交换
void printList(const list<int>&d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	//判断容器是否为空
	if (L1.empty())
	{
		cout << "L1为空" << endl;
	}
	else
	{
		cout << "L1不为空" << endl;
		cout << "L1的元素个数为:" << L1.size() << endl;
	}

	//重新指定大小
	L1.resize(10,10000);
	printList(L1);

	L1.resize(2);
	printList(L1);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

list容器——插入和删除

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//list容器赋值和交换
void printList(const list<int>&d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L;
	
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);

	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);
	
	printList(L);

	//尾删
	L.pop_back();
	printList(L);

	//头删
	L.pop_front();
	printList(L);

	//insert插入
	list<int>::iterator it = L.begin();
	L.insert(++it, 1000);
	printList(L);

	//list容器是双向迭代器  不能跳跃移动
	//L.insert(L.begin() + 1, 100000);//err
	//printList(L);

	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);

	//移除
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	printList(L);
	L.remove(10000);//按值删除  删除所有的10000
	printList(L);

	//清空
	L.clear();
	printList(L);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

list容器——数据存取

list容器底层是链表 存储的不是连续的空间 不支持随机访问 不能用[]或者at直接进行访问

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//list容器赋值和交换
void printList(const list<int>&d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//L1[0]不可以用 []访问list容器中的元素
	//L1[0];err
	//L1.at(0);err
	//原因是list本质是链表，不是用连续的线性空间存储的，迭代器也是不支持随机访问的

	cout << "第一个元素为: " << L1.front() << endl;
	cout << "最后一个元素为:" << L1.back() << endl;

	//验证迭代器是不支持随机访问的
	list<int>::iterator it = L1.begin();
	it++;//right 支持双向++  --
	it--;//right
	//it = it + 1;//err
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

list容器——反转和排序

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
using namespace std;

//list容器赋值和交换
void printList(const list<int>&d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;

	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "反转前:" << endl;
	printList(L1);

	//反转
	L1.reverse();
	cout << "反转后:" << endl;
	printList(L1);
}

//如果返回为true，则让两个参数进行交换，如果返回false则不动
bool myCompare(int v1, int v2)
{
	//降序  就让第一个数 > 第二个数
	return v1 > v2;
}

//排序
void test02()
{
	list<int>L1;

	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);
	
	//排序
	cout << "排序前: " << endl;
	printList(L1);

	//所有不支持随机访问迭代器的容器，不可以用标准的算法
	//不支持随机访问迭代器的容器，内部会提供对应的一些算法
	//sort(L1.begin(),L1.end());//err
	L1.sort();//默认排序规则 从小到大 升序
	cout << "排序后: " << endl;
	printList(L1);

	L1.sort(myCompare);
	printList(L1);
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

list容器——排序案例

案例描述:将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高排序
规则:按照年龄进行升序，如果年龄相同按照身高进行降序

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
using namespace std;

class Person
{
public:
	Person(string name,int age,int height)
	{
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}

	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;
	}
	else
	{
		//按照年龄  升序
		return p1.m_Age < p2.m_Age;
	}
}

void test01()
{
	list<Person>L1;

	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 180);
	Person p3("孙权", 40, 170);
	Person p4("赵云", 25, 190);
	Person p5("关羽", 35, 160);
	Person p6("张飞", 35, 200);

	L1.push_back(p1);
	L1.push_back(p2);
	L1.push_back(p3);
	L1.push_back(p4);
	L1.push_back(p5);
	L1.push_back(p6);

	for (list<Person>::iterator it = L1.begin(); it != L1.end(); it++)
	{
		cout << "姓名:" << (*it).m_Name << " 年龄:" << (*it).m_Age << " 身高: " << (*it).m_Height << endl;
	}

	//排序
	cout << "-----------------------------" << endl;
	cout << "排序后:" << endl;

	L1.sort(comparePerson);
	for (list<Person>::iterator it = L1.begin(); it != L1.end(); it++)
	{
		cout << "姓名:" << (*it).m_Name << " 年龄:" << (*it).m_Age << " 身高: " << (*it).m_Height << endl;
	}
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}