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;
}
