c语言表达式求值 中缀表达式转后缀表达式 求值

中转后 具体转换方式:

1.从左到右遍历需要计算的字符串

2.若是运算数,直接压入后缀表达式栈

3.若是左括号,直接压入运算符栈,(括号是最高优先级,无需比较)(入栈后优先级降到最低,确保其他符号正常入栈)

4.若是右括号,(意味着括号已结束)不断弹出运算符栈顶运算符并输出到后缀表达式栈

直到遇到左括号(弹出但不输出)

5.运算符,将该运算符与运算符栈顶运算符进行比较,

如果优先级高于栈顶运算符则压入运算符栈(该部分运算还不能进行),

 如果优先级低于等于栈顶运算符则将栈顶运算符弹出到后缀表达式栈然后比较新的栈顶运算符.

(低于弹出意味着前面部分可以运算,先输出到后缀表达式栈一定是高优先级运算符,

等于弹出是因为同等优先级,从左到右运算)

直到优先级大于栈顶运算符或者栈空,再将该运算符入运算符栈

6.如果字符串处理完毕,则按顺序从运算符栈弹出所有运算符到后缀表达式栈

使用后缀表达式计算的方法：

1、 按顺序取后缀表达式的每个值

2、 若是数字 则入栈

3、 若是操作符 则从栈取出两个数字 进行运算 运算之后再将结果入栈

4、 循环上述过程知道后缀表达式结束 栈顶元素（栈中只有一个元素）即为结果

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#define NUM 0
#define OPERATION 1
typedef struct {//栈中的结点
    int val;
    int type;
} Node;
typedef struct {//栈
    const char* name;//栈名
    Node* sta;//结点
    int size;//最多存储多少个元素
    int cnt;//当前存储了多少个元素
} MyStack;
void trace(MyStack* s)//栈的遍历
{
    int i;
    printf("%s栈中的元素为：", s->name);
    for (i = 0; i < s->cnt; i++) {
        if (s->sta[i].type == NUM) {//若是数字
            printf("%d ", s->sta[i].val);
        }
        else {//若是字符
            printf("%c ", (char)s->sta[i].val);
        }
    }
    printf("
");
}
void sFree(MyStack* s)//释放栈
{
    if (s->sta != NULL) {
        free(s->sta);
        s->sta = NULL;
    }
    return;
}
int sInit(MyStack* s, const char* name, int size)//初始化栈
{
    s->name = name;
    s->size = size;
    s->sta = (Node*)calloc(s->size, sizeof(Node));//calloc申请后 其中存的都是0
    if (s->sta == NULL) {
        return -1;//分配失败
    }
    s->cnt = 0;//当前栈中元素有0个
    return 0;//分配成功
}
void sPush(MyStack* s, Node item)//入栈一个元素
{
    if (s->cnt == s->size) {
        printf("栈空间不足
");
        return;
    }
    s->sta[s->cnt] = item;
    s->cnt++;
    return;
}
bool sIsEmpty(MyStack* s)//判断栈是否为空
{
    return s->cnt == 0;
}
void sPop(MyStack* s, Node* item)//删除栈顶元素 并返回值到item
{
    if (sIsEmpty(s)) {
        return;
    }
    *item = s->sta[s->cnt - 1];
    s->cnt--;
    return;
}
void sTop(MyStack* s, Node* item)//获得栈顶元素到item  不删除栈顶袁术
{
    if (sIsEmpty(s)) {
        return;
    }
    *item = s->sta[s->cnt - 1];
    return;
}
bool myIsNum(char ch)//判断是否是数字
{
    return ch >= '0' && ch <= '9';
}
bool myIsOper(char ch)//判断是否是运算符
{
    return ch == '+' || ch == '-' || ch == '*' || ch == '/'||ch=='('||ch==')';
}
//处理数值
void procNum(MyStack* postfix_expression, char* s, int len, int* pi)
{
    int i = *pi;//令i等于当前在处理的元素的坐标
    int num=0;//当前数字的值 具体是多少
    Node item_num;
    while (myIsNum(s[i]))
    {
        num = num * 10 + s[i]-'0';
        i++;
    }
    //新建结点
    item_num.type = NUM;
    item_num.val = num;
    //数字直接入后缀表达式的栈
    sPush(postfix_expression, item_num);
    *pi = i-1;//改变calculate_postfix_expression 中i的值
    return;
}
//处理运算符
void procOper(MyStack* postfix_expression, MyStack* s_oper, char* s, int len, int* pi)
{
    int i = *pi;
    Node item;
    Node top_item;
    Node pop_item;
    if (s[i] == '(')//如果是( 直接存入运算符栈
    {
        item.type = OPERATION;
        item.val = s[i];
        sPush(s_oper, item);
    }
    else if (s[i] == ')')//若是) 则弹出到(为止
    {
        int flag = 0;//是否找到了 (
        while (!sIsEmpty(s_oper)) {
            sPop(s_oper, &pop_item);
            if (pop_item.val == '(') {//若找到了左括号退出
                flag = 1;
                break;
            }
            sPush(postfix_expression, pop_item);//若未找到左括号 则一直从运算符栈中pop
        }
        if (!flag)
        {
            printf("括号不匹配！");
            exit(0);
        }
    }
    //如果是乘除
    else if (s[i] == '*' || s[i] == '/') 
    {
        item.type = OPERATION;
        item.val = s[i];
        while (!sIsEmpty(s_oper)) {
            sTop(s_oper, &top_item);
            //如果当前运算符栈的栈顶是+ - (
            //则* /级别较高 则跳出循环
            if (top_item.val == '+' || top_item.val == '-' || top_item.val == '(') {
                break;
            }
            //若当前运算符栈顶不是+ - ( 则是* /
            //则需先把* / pop完 
            sPop(s_oper, &pop_item);
            sPush(postfix_expression, pop_item);
        }
        //才能将当* /入栈
        sPush(s_oper, item);
    }
    //如果是 + -
    else if (s[i] == '+' || s[i] == '-')
    {
        item.type = OPERATION;
        item.val = s[i];
        while (!sIsEmpty(s_oper)) {
            sTop(s_oper, &top_item);
            //如果当前运算符栈的栈顶是 (
            //则当前运算符级别较高 则跳出循环
            if (top_item.val == '(') {
                break;
            }
            //若当前运算符栈顶不是 ( 则是+ - * /
            //则需先把+ - * /pop完 
            sPop(s_oper, &pop_item);
            sPush(postfix_expression, pop_item);
        }
        //才能将当+ - 入栈
        sPush(s_oper, item);
    }
    else 
    {
        printf("输入了非空格 非数字 非运算符的元素 %c
", s[i]);
        exit(0);
    }
    return;
}
//计算后缀表达式 存储在s_trans中
void calculate_postfix_expression(MyStack* postfix_expression, MyStack* s_oper, char* s, int len)
{
    int i;
    int ret;
    int num;
    Node item;
    for (i = 0; i < len; i++) {
        if (s[i] == ' ') {//当前输入为空格时 跳过
            continue;
        }
        if (myIsNum(s[i])) {//当前是数字时
            procNum(postfix_expression, s, len, &i);
            continue;
        }
        if (myIsOper(s[i])) {//当前是运算符时 进入运算的处理程序
            procOper(postfix_expression, s_oper, s, len, &i);
            continue;
        }
        printf("输入了非空格 非数字 非运算符的元素 %c
", s[i]);
        exit(0);
    }
    //若运算栈不为空 依次pop出运算栈中的元素 再push到后缀表达式栈
    while (!sIsEmpty(s_oper)) {
        sPop(s_oper, &item);
        sPush(postfix_expression, item);
    }
    return;
}
int cal(MyStack* postfix_expression, MyStack* s_num)//进行计算
{
    int i;
    Node n1, n2;
    Node item;
    //顺序取出栈中的每个元素
    for (i = 0; i < postfix_expression->cnt; i++) {
        //item为后缀表达式中顺序取的第i个元素
        item = postfix_expression->sta[i];
        //若一直是数字 则一直放进数字栈
        if (item.type == NUM) {
            sPush(s_num, item);
            continue;//开始下一次循环
        }
        //执行到这里证明不是数字 是运算符了
        sPop(s_num, &n2);//从栈中拿出两个元素到n2 n1中
        sPop(s_num, &n1);
        if (item.val == '+') {
            n1.val += n2.val;
        }
        else if (item.val == '-') {
            n1.val -= n2.val;
        }
        else if (item.val == '*') {
            n1.val *= n2.val;
        }
        else {
            n1.val /= n2.val;
        }
        sPush(s_num, n1);//再将此次运算结果入数字栈
    }
    return s_num->sta[0].val;//最后数字栈中的第一个元素就是 计算结果
}
int calculate(char* s) {//进行计算
    int ret;
    int len;
    if (s == NULL||(len=strlen(s))==0) {
        return 0;
    }
    MyStack s_num;//数字栈
    MyStack s_oper;//运算符栈
    MyStack postfix_expression;//后缀表达式栈
    if (sInit(&s_num, "数字", len)==-1||
        sInit(&s_oper, "运算符", len)==-1||
        sInit(&postfix_expression, "后缀表达式", len)==-1
        ) //若初始化三个栈失败的话 则释放内存 return 0
    {
        sFree(&s_num);
        sFree(&postfix_expression);
        sFree(&s_oper);
        return 0;
    }
    //计算后缀表达式
    calculate_postfix_expression(&postfix_expression, &s_oper, s, len);
    //显示后缀表达式
    trace(&postfix_expression);
    //使用后缀表达是进行计算
    ret = cal(&postfix_expression, &s_num);
    //释放栈的空间
    sFree(&postfix_expression);
    sFree(&s_oper);
    sFree(&s_num);
    //返回结果
    return ret;
}
int main()
{
    char str[10000];
    scanf("%[^
]", str);//可以输入空格 回车停止输入
    printf("计算结果为%d
", calculate(str));
}
//例子 (((50+20)+(2*3))/14)