数据结构基础3：栈与队列

栈与队列

栈

先进后出

栈算法模板：

// tt表示栈顶下标
int stk[N], tt = 0;

// 向栈顶插入一个数x
void push(int x)
{
    stk[ ++ tt] = x;
}

// 从栈顶弹出一个数
void pop()
{
    tt -- ;
}

// 查询栈顶元素
int query()
{
    return stk[tt];
}

// 判断栈是否为空
bool empty()
{
    if (tt > 0)	return false;
    else	return true;
}

表达式求值

先看下只有 + 和 * 的。

输入长度为n的字符串，例如：1+2+345

输出表达式的值，即：63

应该用什么数据结构？

栈。

应该先计算哪一步？

实际应该先计算1+2。

“表达式求值”问题，两个核心关键点：

（1）双栈，一个操作数栈，一个运算符栈；

（2）运算符优先级，栈顶运算符，和，即将入栈的运算符的优先级比较：

如果栈顶的运算符优先级低，新运算符直接入栈

如果栈顶的运算符优先级高，先出栈计算，新运算符再入栈

仍以1+2+345举例，看是如何利用上述两个关键点实施计算的。

首先，这个例子只有+和*两个运算符，所以它的运算符表是：

这里的含义是：

（1）如果栈顶是+，即将入栈的是+，栈顶优先级高，需要先计算，再入栈；

（2）如果栈顶是+，即将入栈的是*，栈顶优先级低，直接入栈；

（3）如果栈顶是*，即将入栈的是+，栈顶优先级高，需要先计算，再入栈；

（4）如果栈顶是*，即将入栈的是*，栈顶优先级高，需要先计算，再入栈；

有了运算符表，一切就好办了。

一开始，初始化好输入的字符串，以及操作数栈，运算符栈。

一步步，扫描字符串，操作数一个个入栈，运算符也入栈。

下一个操作符要入栈时，需要先比较优先级。

栈内的优先级高，必须先计算，才能入栈。

计算的过程为：

（1）操作数出栈，作为num2；

（2）操作数出栈，作为num1；

（3）运算符出栈，作为op；

（4）计算出结果；

（5）结果入操作数栈；

接下来，运算符和操作数才能继续入栈。下一个操作符要入栈时，继续比较与栈顶的优先级。

栈内的优先级低，可以直接入栈。

字符串继续移动。

又要比较优先级了。

栈内的优先级高，还是先计算（3*4=12），再入栈。

不断入栈，直到字符串扫描完毕。

不断出栈，直到得到最终结果3+60=63，算法完成。

总结

“表达式求值”问题，两个核心关键点：

（1）双栈，一个操作数栈，一个运算符栈；

（2）运算符优先级，栈顶运算符，和，即将入栈的运算符的优先级比较：
如果栈顶的运算符优先级低，新运算符直接入栈

如果栈顶的运算符优先级高，先出栈计算，新运算符再入栈

这个方法的时间复杂度为O(n)，整个字符串只需要扫描一遍。

运算符有±/()~^&都没问题，如果共有n个运算符，会有一个nn的优先级表。

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

stack<int> num;
stack<char> op;

//优先级表
unordered_map<char, int> h{ {'+', 1}, {'-', 1}, {'*',2}, {'/', 2} };


void eval()//求值
{
    int a = num.top();//第二个操作数
    num.pop();

    int b = num.top();//第一个操作数
    num.pop();

    char p = op.top();//运算符
    op.pop();

    int r = 0;//结果 

    //计算结果
    if (p == '+') r = b + a;
    if (p == '-') r = b - a;
    if (p == '*') r = b * a;
    if (p == '/') r = b / a;

    num.push(r);//结果入栈
}

int main()
{
    string s;//读入表达式
    cin >> s;

    for (int i = 0; i < s.size(); i++)
    {
        if (isdigit(s[i]))//数字入栈
        {
            int x = 0, j = i;//计算数字
            while (j < s.size() && isdigit(s[j]))
            {
                x = x * 10 + s[j] - '0';
                j++;
            }
            num.push(x);//数字入栈
            i = j - 1;
        }
        //左括号无优先级，直接入栈
        else if (s[i] == '(')//左括号入栈
        {
            op.push(s[i]);
        }
        //括号特殊，遇到左括号直接入栈，遇到右括号计算括号里面的
        else if (s[i] == ')')//右括号
        {
            while(op.top() != '(')//一直计算到左括号
                eval();
            op.pop();//左括号出栈
        }
        else
        {
            while (op.size() && h[op.top()] >= h[s[i]])//待入栈运算符优先级低，则先计算
                eval();
            op.push(s[i]);//操作符入栈
        }
    }
    while (op.size()) eval();//剩余的进行计算
    cout << num.top() << endl;//输出结果
    return 0;
}

普通队列

先进先出

普通队列算法模板：

// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;

// 向队尾插入一个数
void push(int x)
{
    q[ ++ tt] = x;
}

// 从队头弹出一个数
void pop()
{
    hh ++ ;
}

// 队头的值
int query_head()
{
    return q[hh];
}

// 队尾的值
int query_tail()
{
    return q[tt];
}

// 判断队列是否为空
bool empty()
{
    if (hh <= tt)	return false;
    else	return true;
}

循环队列

循环队列算法模板：

// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;

// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;

// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;

// 队头的值
q[hh];

// 判断队列是否为空
if (hh != tt)
{

}

单调栈

给定一个序列，求序列中的每个数左边 离他最近的并且比它小的数

暴力做法：

//i的左边比i小的第一个数
for(int i = 0; i < n; i ++)
{
    for(int j = i - 1; j >= 0; j --)
    {
        if(a[i] > a[j])
        {
            cout << a[j] << endl;
            break;
        }
    }
}

对于暴力寻找性质：

暴力：可以用栈存储i左边的所有元素，对于第$i$个元素，查找栈顶是否比它小，大的话就弹出

优化：栈里面有些元素是永远不会作为答案出现的，假如$a_3>=a_5$，那么对于$5$往后的询问，$a_3$永远不会出现为答案

如果存在$x<y$，并且$a_x=a_y$ ，那么$a_x$就可以被删掉，那么栈里面 存储的就一定是严格单调上升的序列了

求第$i$个数左边，离得最近的比它小的数：

$x<y<i$，如果存在$a[x]>=a[y]$ 的话，假如$a[y] < a[i] $，那么就不会考虑$a[x]$了，所以$a[x] $就没有存在的必要了

所以只需要每次判断栈顶是否比当前元素大，如果大的话就弹出，直到栈顶比当前元素小，先输出栈顶再push当前元素

复杂度：O(n)

注意点：

1. 在用数组模拟栈的时候，需要$++tt$，先加再赋！！！
2. 注意$check$函数里面的等于的情况，当栈顶元素和当前元素相等的时候，也不会用到前面的元素了

单调栈算法模板：

常见模型：找出每个数左边离它最近的比它大/小的数
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
    while (tt && check(stk[tt], i)) tt -- ;
    // if(tt)  cout << stk[tt] << " ";
    // else    cout << "-1 ";
    stk[ ++ tt] = i;
}

单调队列

求滑动窗口中的最大值/最小值

窗口可以用队列来维护

当窗口移动的时候，新的元素从队尾进，旧元素从队尾出

优化：

队列里面有些元素是没有用的

（使用双端队列）

求滑动窗口最大值：

滑动窗口的初始状态是指滑动窗口内只有一个元素，在此基础上向后移动，

第0次有1个元素，队头为-2，

第1次有2个元素，队头为-1，

第2次有3个元素，队头为0，

从第$k-1$次开始出现全

第$i $次有3个元素，队头为$ i - 2$，即队头下标为$ i - k + 1$，就可以判断队头有没有出去

我们每次将有可能成为最大值的元素放入队列末尾

对于当前元素，我们判断队列末尾是不是比当前元素小，假如队尾元素比当前元素小，就不可能成为最大的元素了，就从后面弹出，

直到队列内没有比当前元素更小的元素

但是队列头上可能存在比当前元素更大的元素，所以区间的最大值为队列头

但是每次需要判断队头有没有出去，如果出去了，最大值就变了

单调队列里面存的是下标

单调队列算法模板：

//常见模型：找出滑动窗口中的最大值/最小值
//单调队列里面存的是下标
//当前队首元素为 i - k + 1 
int hh = 0, tt = -1;
for (int i = 0; i < n; i ++ )
{
    while (hh <= tt && check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口
    while (hh <= tt && check(q[tt], i)) tt -- ;	  // 将入队元素与队尾元素比较大小
    q[ ++ tt] = i;
    // 队头元素是最值
}