STL常用容器-stack栈容器&queue队容器

stack栈的基本概念

stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口；

只允许在栈顶新增元素、删除元素、获取栈顶元素，但是除了栈顶之外，其他位置都不能存取元素，只有栈顶元素能被外界访问，也就是说stack不具有遍历行为，没有迭代器，不支持随机访问。

栈中进入数据称为 --- 入栈 push

栈中弹出数据称为 --- 出栈 pop

特性：

不能遍历

不支持随机存取

只能通过栈顶插入元素

只能通过top从栈顶获取元素

stack的常用的函数

功能描述：栈容器常用的对外接口

构造函数：

stack<T> stk; // stack才用模板类来实现， stack对象默认构造

stack(const stack &stk); // 拷贝构造函数

赋值操作：

stack &operator =(const stack & stk); // 重载赋值运算符

数据存取：

push(elem); // 向栈顶来添加元素

pop(); // 从栈顶来删除元素

top(); // 返回栈顶元素

大小操作：

empty() // 判断栈是否为空

size() // 返回栈的大小

#include <iostream>
#include <stack>;
using namespace std;
void test01()
{
	// 构造函数
	stack<int> s;

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

	// 拷贝构造
	stack<int> s1(s);

	cout << "s的栈顶元素：" << s.top() << endl;
	cout << "s的栈大小：" << s.size() << endl;
	cout << "s是否为空：" << s.empty() << endl;

	// 出栈
	s.pop();
	s.pop();
	s.pop();
	cout << "s是否为空：" << s.empty() << endl;

	// 赋值操作
	stack<int> s2;
	s2 = s1;
	cout << "s2的栈顶元素：" << s2.top() << endl;
}

// 打印栈中所有元素的函数模板
template<class T>
void printStack(stack<T>& stk)
{
	while (!stk.empty())
	{
		cout << stk.top() << " ";
		stk.pop();
	}
	cout << endl;
}
void test02()
{
	// 获取栈中的所有元素
	stack<string> stk;
	stk.push("abc");
	stk.push("bcd");
	stk.push("cde");
	printStack(stk);

	stack<int> stk1;
	stk1.push(10);
	stk1.push(20);
	stk1.push(30);
	printStack(stk1);
}

总结：

入栈 --- push

出栈 --- pop

返回栈顶 --- top

判断栈是否为空 --- empty

返回栈大小 --- size

stack的练习

//练习1：括号匹配的问题
// 给一个由(和)组成的字符串，判断左右的括号是否成对出现。
// 匹配情况：abc(mn(op)w(xy))
// 不匹配的情况：)sk(kpi(qw)bv  uop(uio)ru(ab  (sa)cf)nn(k(ui)

// 思路：遍历字符串，当遇到左括号的时候，先入栈，第一个左括号就是最外层的，第二个就是第二层的
// 以此类推，如果遇到右括号就要匹配一个左括号，让左括号出栈，也要检查栈中是否还有左括号
// 如果有就让它出栈，如果没有就说明不匹配，直接return false终止函数。
// 当遍历结束的时候 要检查栈是否为空，如果为空，说明全部匹配成功，否则匹配失败

bool isMatch(string& s)
{
	stack<char> stk; // 准备一个栈来存放左括号
	for (int i = 0; i < s.size(); i++)
	{
		if (s[i] == '(') // 如果出现的左括号，就直接入栈
		{
			stk.push('(');
		}
		else if (s[i] == ')')
		{
			if (stk.empty()) // 如果栈为空，没有左括号，就直接return false终止函数
			{
				return false;
			}
			else // 如果不为空，就直接弹出一个左括号	
			{
				stk.pop();
			}
		}
	}
	// 遍历结束之后，要检查栈内是否为空，如果为空就说明匹配成功，否则失败
	if(stk.empty())
	{
		return true;
	}
	else
	{
		return false;
	}
}


//练习2：多种括号的匹配性问题
// 给定一个由大括号、中括号、小括号和其他字符组成的字符串，判断左右括号是否匹配
// 匹配情况：(abc[de]fk){s[ed]f}
// 不匹配情况：(2345]

// 定义函数来判断左右括号是否匹配
bool sameType(char c1, char c2)
{
	if (c1 == '(' and c2 == ')')
	{
		return true;
	}
	else if (c1 == '[' and c2 == ']')
	{
		return true;
	}
	else if (c1 == '{' and c2 == '}')
	{
		return true;
	}
	else
	{
		return false;
	}

}
bool isMatchAll(string& s)
{
	stack<char> stk; // 准备一个栈来存放左括号
	for (int i = 0; i < s.size(); i++)
	{
		if (s[i] == '(' || s[i] == '[' || s[i] == '{') // 如果出现的左括号，就直接入栈
		{
			stk.push(s[i]);
		}
		else if (s[i] == ')' || s[i] == ']' || s[i] == '}') // 如果出现右括号
		{
			if (stk.empty()) // 如果栈为空，没有左括号，就直接return false终止函数
			{
				return false;
			}
			else 
			{
				if (sameType(stk.top(), s[i]))// 如果不为空，判断左右括号是否是匹配的，如果是才弹出，否则直接返回false终止函数
				{
					stk.pop();
				}
				else
				{
					return false;
				}
			}
		}
	}
	// 遍历结束之后，要检查栈内是否为空，如果为空就说明匹配成功，否则失败
	if (stk.empty())
	{
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	//string str1 = "abc(mn(op)w(xy))";
	//string str2 = ")sk(kpi(qw)bv";
	//string str3 = "uop(uio)ru(ab";
	//string str4 = "(sa)cf)nn(k(ui)";

	//cout << isMatch(str1) << endl;
	//cout << isMatch(str2) << endl;
	//cout << isMatch(str3) << endl;
	//cout << isMatch(str4) << endl;

	string str1 = "(abc[de]fk){s[ed]f}";
	string str2 = "(abc]";

	cout << isMatchAll(str1) << endl;
	cout << isMatchAll(str2) << endl;
	return 0;
}

queue单端队列

queue 基本概念

queue是一种先进先出的数据结构，可以理解为栈的双开口版本，有两个口，分别为队头和队尾，队尾只能进不能出，队头只能出，queue只允许从队尾添加元素，只有队头和队尾可以被外界访问。

队列容器允许从一端新增元素，从另一端移除元素

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 --- 入队 push

队列中出数据称为 --- 出队 pop

queue的常用函数

功能描述：栈容器常用的对外接口

构造函数：

queue que; //queue采用模板类实现，queue对象的默认构造形式

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

赋值操作：

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

数据存取：

push(elem); //往队尾添加元素

pop(); // 从队头移除第一个元素

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

front(); //返回第一个元素

大小操作：

empty(); //判断堆栈是否为空

size(); // 返回容器大小

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

// 打印队列中的元素的函数模板
template<class T>
void printQueue(queue<T>& que)
{
	while (!que.empty())
	{
		cout << que.front() << " "; // 先打印队头的元素
		que.pop(); // 打印完成后再弹出队头元素
	}
	cout << endl;
}

// 队列的常用函数
void test01()
{
	queue<int> que;
	for (int i = 1; i < 11; i++)
	{
		que.push(i);
	}

	cout << "队头：" << que.front() << endl;
	cout << "队尾：" << que.back() << endl;

	que.pop(); // 弹出队头元素

	cout << "队头：" << que.front() << endl;
	cout << "队尾：" << que.back() << endl;

	cout << "大小：" << que.size() << endl;
	cout << "是否为空：" << que.empty() << endl;

	printQueue(que);
}

// 在queue容器中存储自定义类型Person(mName, mAge),并且遍历输出
class Person
{
public:
	string m_Name;
	int m_Age;
	Person(string name, int age) :m_Name(name), m_Age(age) {}
};

//创建对象，添加到queue容器中进行遍历
void test02()
{
	//准备一个存储Person类型的队列
	queue<Person> q;
	// 准备对象
	Person p1("唐僧", 500);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 300);

	// 将对象依次添加到容器中
	q.push(p1);
	q.push(p2);
	q.push(p3);

	// 展示每个对象的属性
	while (!q.empty())
	{
		cout << "姓名：" << q.front().m_Name << "\t年龄：" << q.front().m_Age << endl;
		q.pop();
	}
}

总结：

入队 --- push

出队 --- pop

返回队头元素 --- front

返回队尾元素 --- back

判断队是否为空 --- empty

返回队列大小 --- size

queue的练习

// 2、对奇数和偶数进行分类
// 有一个queue，存储了一些整数，要求把这些整数分类，奇数放到新的queue容器中，偶数放到另一组中，并且保持原来的先后顺序。
// [1,2,3,4]  处理完之后为[1,3]  [2,4];

void numType(queue<int>& que)
{
	queue<int> q1;
	queue<int> q2;

	while (!que.empty())
	{
		if (que.front() % 2 != 0)
		{
			q1.push(que.front()); // 奇数进q1
			que.pop();
		}
		else
		{
			q2.push(que.front()); // 偶数进q2
			que.pop();
		}
	}
	
	cout << "奇数队列q1的值是：";
	while (!q1.empty())
	{
		cout << q1.front() << " ";
		q1.pop();
	}

	cout << "偶数队列q2的值是：";
	while (!q2.empty())
	{
		cout << q2.front() << " ";
		q2.pop();
	}

}

// 3、翻扑克牌游戏
// 有一堆扑克牌，里面有n张牌，第一次从牌堆顶拿出一张牌并输出，第二次将牌放到牌堆最底下，重复执行，直到牌堆没牌，也就是说，奇数牌输出，偶数牌放回。
// 输入 [1,2,3,4,5,6,7,8]
// 牌的顺序 [1,3,5,7,2,4,6,8]
// 输出的结果 1,3,5,7
void pai(queue<int>& q)
{
	bool b = true; // 给一个布尔值来作为判断奇偶的一个标志变量，初始化为true，默认为奇数，偶数可以改为false
	while (!q.empty())
	{
		if (b)
		{
			cout << q.front() << " "; // 第一次抽牌为真的时候直接展示
		}
		else // 偶数不展示，需要回到牌堆底部，即入队
		{
			q.push(q.front()); // 将偶数牌放回到最下面
		}
		q.pop(); // 无论奇数还是偶数，都要出队
		b = !b; // 每次循环都要将标志变量取反
	}
	cout << endl;
}

int main()
{

	//queue<int> que;
	//que.push(1);
	//que.push(2);
	//que.push(3);
	//que.push(4);
	//numType(que);

	queue<int> que;
	que.push(1);
	que.push(2);
	que.push(3);
	que.push(4);
	que.push(5);
	que.push(6);
	que.push(7);
	que.push(8);
	pai(que);
	return 0;
}