栈4-后缀表达式

中缀转后缀

数字: 直接输出

左括号:  进栈

运算符号: 与栈顶符号进行优先级比较

栈顶若是左括号, 优先级最低

栈顶符号优先级低:  此符号进栈

栈顶符号优先级不低, 弹出栈顶符号后进栈

右括号: 将栈顶符号弹出并输出, 知道匹配到左括号

遍历结束: 弹出并输出所有符号

自定义栈结构

typedef struct MYCHAR{
    LinkNode node;
    char *p;
} MyChar;

创建栈结点

//创建MyChar
MyChar* CreateMyChar(char *p){
    MyChar *mychar = (MyChar*)malloc(sizeof(MyChar));
    mychar->p = p;
    return mychar;
}

判断

//判断数字
int isNumber(char c){
    return c>='0' && c<='9';
}
//左括号
int isLeft(char c){
    return c=='(';
}
//右括号
int isRight(char c){
    return c==')';
}
//判断是不是运算符号
int isOperator(char c){
    return c=='+' || c=='-' || c=='*' || c=='/';
}

操作

//数字操作
void numberOperate(char *c){
    cout << *c << " ";
}
//左括号操作
void leftOperate(LinkStack *stack, char *p){
    Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
}
//右括号操作
void rightOperate(LinkStack *stack, char *p){
    while(Size_LinkStack(stack) >0){
        MyChar *mychar = (MyChar*)Top_LinkStack(stack);
        //如果匹配到左括号, 弹出
        if(isLeft(*(mychar->p))){
            Pop_LinkStack(stack);
            break;
        }
        cout << *(mychar->p) << " ";
        Pop_LinkStack(stack);
        //释放内存
        // free(mychar);
    }    
}
//返回符号的优先级
int GetPriority(char c){
    if(c=='*' || c=='/') return 2;
    
    if(c=='+' || c=='-') return 1;

    return 0;
}

运算符号操作

//运算符号操作
void operatorOperate(LinkStack *stack, char *p){
    //取出栈顶符号
    MyChar *mychar = (MyChar*)Top_LinkStack(stack);
    //栈为空
    if(mychar==NULL){
        Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
        return;
    }
    //如果栈顶优先级低于当前符号, 当前符号直接入栈
    if(GetPriority(*(mychar->p)) < GetPriority(*p)){
        Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
        return;
    }
    //栈顶符号优先级不低, 弹出栈顶符号后进栈
    else{
        while(Size_LinkStack(stack)>0){
            MyChar *mychar2 = (MyChar*)Top_LinkStack(stack);
            //如果栈顶优先级较低, 当前符号入栈
            if(GetPriority(*(mychar2->p)) < GetPriority(*p)){
                Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
                break;
            } 
            //如果栈顶优先级不低于,弹出
            //输出栈顶
            cout << *(mychar2->p);
            //弹出
            Pop_LinkStack(stack);
            //释放
            free(mychar2);
        }
    }
}

测试

int main(){
    // 8 3 1 - 5 * +
    char *str = "8+(3-1)*5";
    char *p = str;
    //创建栈
    LinkStack* stack = Init_LinkStack();

    while(*p!='\0'){
        //数字, 直接输出
        if(isNumber(*p)){
            numberOperate(p);
        }
        //左括号, 直接进栈
        if(isLeft(*p)){
            leftOperate(stack,p);
        }
        //右括号
        if(isRight(*p)){
            rightOperate(stack,p);
        }
        //如果是运算符号 
        if(isOperator(*p)){
            operatorOperate(stack,p);
        }

        p++;
    }
    //把栈剩余的内容输出并弹出
    while(Size_LinkStack(stack)>0){
        MyChar *mychar = (MyChar*)Top_LinkStack(stack);
        cout << *(mychar->p) << " ";
        Pop_LinkStack(stack);
    }
    
    cout << endl;

    system("pause");
    return 0;
}