括号匹配及表达式求值

 1.1 栈在括号匹配中的应用  

---

假设表达式中允许包含三种括号：圆括号“( )”，中括号“[ ]”，花括号“{ }”。其嵌套顺序任意，即{ ( ( [ ] ) ) }或{ ( [ ] [ ] )}等均为正确的格式，{ ) [ ] ( }或{ [ ] ( ) {等均为不正确的格式。

则：输入由以上三种括号构成的字符串，如何判断字符串里括号格式的正确性？

问题分析：

1.最后出现的左括号最先被匹配(LIFO)——“栈”。

2.每出现一个右括号，就“消耗”一个左括号——“出栈”。

算法思路：

1.创建一个空栈，开始顺序扫描所有字符。

2.扫描到左括号，入栈。

3.扫描到右括号，则弹出栈顶元素（已入栈的左括号）。若栈为空，则退出报错。

4.检查两个括号是否匹配。若不匹配，则退出报错。

5.扫描完所有字符后，检查是否栈空，栈空说明匹配成功。若栈不空，说明还有左括号剩余，则退出报错。

匹配失败的三种情况：

1.右括号单身（右括号要匹配，栈已空）。

2.左右括号不匹配。

3.左括号单身（右括号匹配完，栈不为空）。

实现代码：

#define MaxSize 10            //定义栈中元素的最大个数
typedef struct{
    char data[MaxSize];       //静态数组存放栈中元素
    int top;                  //栈顶指针
}SqStack;
//初始化栈
void InitStack(SqStack &S){
    S.top = -1;
}
//判断栈是否为空
bool StackEmpty(SqStack S){
    if(S.top==-1)             //栈空
        return true;
    else
        return false;
}
//新元素入栈
bool Push(SqStack &S,char x){
    if(S.top==MaxSize-1)      //栈满，报错
        return false;
    S.data[++S.top] = x;
    return true;
}
//栈顶元素出栈，用x返回
bool Pop(SqStack &S,char &x){
    if(S.top==-1)             //栈空，报错
        return false;
    x = S.data[S.top];
    return true;
}
//判断字符串里括号格式的正确性
bool bracketCheck(char str[],int length){
    SqStack S;
    InitStack(S);             //初始化一个栈
    for(int i=0;i<length;i++){
        if(str[i]=='('||str[i]=='['||str[i]=='{'){
            Push(S,str[i]);   //扫描到左括号，入栈
        }
        else{
            if(StackEmpty(S)) //扫描到右括号，且当前栈空
                return false; //匹配失败
            char topElem;
            Pop(S, topElem);  //栈顶元素出栈
            if(str[i]==')' && topElem!='(')
                return false;
            if(str[i]==']' && topElem!='[')
                return false;
            if(str[i]=='}' && topElem!='{')
                return false;
        }
    }
    return StackEmpty(S);     //检索完全部括号后，栈空说明匹配成功
}

---

 1.2 栈在表达式求值中的应用

---

中缀表达式：运算符在两个操作数的中间。 如：A+B-C*D

后缀表达式：运算符在两个操作数的后面。 如：AB+CD*-

前缀表达式：运算符在两个操作数的前面。 如：-+AB*CD

中缀表达式转后缀表达式：

1.初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。

2.从左到右处理各个元素，直到末尾。

        遇到操作符时，直接加入后缀表达式。

        遇到界限符时，遇到“(”直接入栈，遇到“)”则依次弹出栈内运算符并加入后缀表达式，直到弹出“(”为止。（注意：“(”不加入后缀表达式）

        遇到运算符时，依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到“(”或栈空则停止。之后再把当前运算符入栈。

3.按上述方法处理完所有的字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。

实现代码：

#include<iostream>
#include<stack>
using namespace std;
//判断一个字符是否为操作符
int isoperator(char x){
 if(x=='+'||x=='-'||x=='*'||x=='/'||x=='('||x==')')
     return 1;
 else
     return 0;
}
//给定操作符的优先级
int rnk(char x){
 if(x=='*'|| x=='/')
     return 2;
 if(x=='+'|| x=='-')
     return 1;
 if(x=='(')
     return 0;
 else
     return -1;
}
int main(){
    stack<char>s;
    char exp[100];//存储输入中缀表达式的数组
    char res[100];//存储输出后缀表达式的数组
    cin>>exp;
    int i=0;
    for(int k=0;exp[k]!='\0';k++){
        int a=s.size();
        if(!isoperator(exp[k])){
            res[i++]=exp[k];    //操作数直接放入后缀表达式
            continue;
        }else{
            if(s.empty()){
                s.push(exp[k]);   //如果栈里面是空，直接入栈
                continue;
            }
            if(exp[k]=='('){
                s.push(exp[k]);  //扫描到“(“，”(“入栈
                continue;
            }
            if(exp[k]==')'){
                while(s.top()!='('){
                    res[i++]=s.top();   //扫描到”)",则依次弹出栈内运算符并加入后缀表达式，直到弹出“(”为止
                    s.pop();
                }
                s.pop();
                continue;
            }
            else{   //比较运算符的优先级，依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到栈空则停止
                while((rnk(s.top())>=rnk(exp[k]))&&!s.empty()){
                    res[i++]=s.top();
                    s.pop();
                }
                s.push(exp[k]);   //把当前运算符入栈。
            }
        }
    }
    while(s.size()!=0){   //将栈中剩余运算符依次弹出，并加入后缀表达式
        res[i++]=s.top();
        s.pop();
    }
    for(int j=0;j<i;j++){   //输出后缀表达式
        cout<<res[j];
    }
    cout<<endl;
    return 0;
}

后缀表达式的计算：

特点：最后出现的操作数最先被计算——LIFO（后进先出）。

1. 建立一个栈，从左往右扫描下一个元素，直到处理完所有的元素。

2. 若扫描到操作数则压入栈，并回到1，否则执行3。

3. 若扫描到运算符，则弹出两个栈顶元素，执行相应的运算，运算结果压入到栈顶，回到1。（注意：先出栈的是“右操作数”）

4.若表达式合法，则最后栈中只会留下一个元素，即最终结果。

中缀表达式的计算： 

1.初始化两个栈，操作数栈和运算符栈。

2.若扫描到操作数，压入操作数栈。

3.若扫描到运算符或者界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符，就需要弹出两个操作数栈的栈顶元素并执行相应的运算，运算结果再压回操作数栈）。

实现代码：

class Solution {
public:
    vector<int> function(string s, int index){
        stack<int> stack; 
        int num = 0;
        char op = '+';
        int i;
        for(i = index; i < s.length(); i++){
            //数字转换成int数字
            if(isdigit(s[i])){
                num = num * 10 + s[i] - '0';
                if(i != s.length() - 1)
                    continue;
            }
            //碰到'('时，把整个括号内的当成一个数字处理
            if(s[i] == '('){
                //递归处理括号
                vector<int> res = function(s, i + 1);
                num = res[0];
                i = res[1];
                if(i != s.length() - 1)
                    continue;
            }           
            switch(op){
            //加减号先入栈
            case '+': 
                stack.push(num);
                break;
            case '-':
                //相反数
                stack.push(-num);
                break;
            //优先计算乘号
            case '*':  
                int temp = stack.top();
                stack.pop();
                stack.push(temp * num);
                break;
            }
            num = 0;
            //右括号结束递归
            if(s[i] == ')')
                break; 
            else 
                op = s[i];
        }
        int sum = 0;
        //栈中元素相加
        while(!stack.empty()){  
            sum += stack.top();
            stack.pop();
        }
        return vector<int> {sum, i}; 
    }
    
    int solve(string s) {
        return function(s, 0)[0];
    }
};