表达式求值（链栈实现）

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

#define _CRT_SECURE_NO_WARNINGS//解决vs下直接用scanf报错

typedef struct operandstack//操作数栈
{
    int Operand;//操作数
    struct operandstack* Next;
}OPERAND;

typedef struct operatorstack//运算符栈
{
    char Operator;//运算符
    struct operatorstack* Next;
}OPERATOR;

int Is(char temp);//temp是操作数返回1，否则返回0
void Push_operand(OPERAND* operand_top, int number);//操作数入栈
void Push_operator(OPERATOR* operator_top, char temp);//运算符入栈
int Pop_operand(OPERAND* operand_top);//操作数出栈
char Pop_operator(OPERATOR* operator_top);//运算符出栈
char Precede(char temp1, char temp2);//temp1高优先级就输出‘>'，同优先级输出'=', 低优先级输出 '<'
int Operate(int a, char theta, int b);//返回二元运算 a theta b 的结果

int main(void)
{
    char temp = NULL;//输入的字符
    int number = 0;//字符转换成操作数
    int value = 0;//表达式的值
    int a = 0;//a theta b
    int b = 0;
    char theta = NULL;//二元运算的运算符
    OPERAND* operand_top = (OPERAND*)calloc(1, sizeof(OPERAND));//操作数栈顶
    OPERATOR* operator_top = (OPERATOR*)calloc(1, sizeof(OPERATOR));//运算符栈顶
    OPERAND* operand_s = NULL;//指向操作数栈的指针
    OPERATOR* operator_s = NULL;//指向运算符栈的指针
    operand_top->Next = NULL;//初始化操作数栈
    operator_top->Next = NULL;//初始化运算符栈

    Push_operator(operator_top, '=');//把‘=’压入运算符栈底

    printf("请输入表达式(以=号结尾)：");//表达式求值
    temp = getchar();//读取首个输入
    printf("\n************************************\n");
    while (temp != '=' || operator_top->Next->Operator != '=')//输入为‘=’且运算符栈中仅有‘=’时退出循环
    {
        if (temp == ' ')//忽略空格
        {
            do
            {
                temp = getchar();
            } while (temp == ' ');
        }
        else if (Is(temp) == 1)//temp是操作数返回1，否则返回0
        {
            printf("\n%c是操作数!", temp);
            number = temp - '0';
            temp = getchar();//读取下一个输入
            while (Is(temp) && temp != ' ')//如果下一个输入还是数字，说明这是同一个操作数
            {
                number = 10 * number + (temp - '0');//同一个操作数的不同位
                temp = getchar();
            }
            Push_operand(operand_top, number);//把操作数压入操作数栈
            printf("\n操作数%d进栈了!", number);
        }//if是操作数
        else//temp是运算符
        {
            printf("\n%c是运算符!", temp);
            printf("\n正在比较输入%c和栈顶运算符%c优先级!", temp, operator_top->Next->Operator);
            
            switch (Precede(temp, operator_top->Next->Operator))//比较优先级
            {
            case '>'://temp优先级高
                printf("\n运算符%c进栈了!", temp);
                Push_operator(operator_top, temp);//运算符压入栈
                temp = getchar();
                break;
            case '='://两者优先级相同
                Pop_operator(operator_top);
                temp = getchar();
                break;
            case '<'://temp优先级低
                //将出栈的两个操作数及运算符进行二元运算，运算结果压入操作数栈
                value = Operate(Pop_operand(operand_top) , Pop_operator(operator_top), Pop_operand(operand_top));
                printf("\n二元运算的值为:%d", value);
                printf("\n操作数%d进栈了!", value);
                Push_operand(operand_top, value);//运算结果压入栈
                break;
            default:
                printf("\n优先级错误!");
                exit(-1);
            }//switch
        }//else
    }//while

    if (operand_top->Next == NULL)//操作数栈中没有操作数报错
    {
        printf("\n表达式求值错误!");
        exit(-1);
    }
    printf("\n\n************************************\n");
    printf("\n表达式的值为%d\n", operand_top->Next->Operand);
    printf("\n************************************\n");
    system("pause");
    return 0;
}

int Is(char temp)//temp是操作数返回1，是运算符返回0
{
    char a[7] = { '+', '-', '*', '/', '(', ')', '=' };//运算符
    int i;
    if (temp >= '0' && temp <= '9')
    {
        return 1;
    }
    for (i = 0; a[i] != '\0'; i++)
    {
        if (a[i] == temp)
        {
            return 0;
        }
    }
    printf("\n输入的既不是操作数也不是操作符!");
    exit(-1);
}

void Push_operand(OPERAND* operand_top, int number)//把操作数压入操作数栈
{
    OPERAND* operand_s;
    if ((operand_s = (OPERAND*)calloc(1, sizeof(OPERAND))) == NULL)
    {
        printf("\nclear allocation fail !");
        exit(-1);
    }
    operand_s->Operand = number;
    operand_s->Next = operand_top->Next;
    operand_top->Next = operand_s;
}

void Push_operator(OPERATOR* operator_top, char temp)//把运算符压入运算符栈
{
    OPERATOR* operator_s;
    if ((operator_s = (OPERATOR*)calloc(1, sizeof(OPERATOR))) == NULL)//把‘=’压入栈底
    {
        printf("\nclear allocation fail !");
        exit(-1);
    }
    operator_s->Operator = temp;
    operator_s->Next = operator_top->Next;
    operator_top->Next = operator_s; 
}

int Pop_operand(OPERAND* operand_top)//操作数出栈
{
    int temp;
    OPERAND* p;
    p = operand_top->Next;
    temp = p->Operand;
    operand_top->Next = p->Next;
    free(p);
    //printf("\n返回%d", temp);
    return temp;
}

char Pop_operator(OPERATOR* operator_top)//操作符出栈
{
    char temp;
    OPERATOR* p;
    if (operator_top->Next == NULL)
    {
        printf("\n空栈!");
        exit(-1);
    }
    p = operator_top->Next;
    temp = p->Operator;
    operator_top->Next = p->Next;
    free(p);
    return temp;
}

char Precede(char temp1, char temp2)//比较优先级，temp1高优先级就输出‘>'，同优先级输出'=',temp1低优先级输出 '<'
{
    switch (temp1)
    {
    case '+':
    case '-':
        switch (temp2)
        {
        case '(':
        case '=':
            return '>';
            break;
        case '+':
        case '-':
        case '*':
        case '/':
        case ')':
            return '<';
            break;
        default:
            printf("\n优先级比较错误!");
            exit(-1);
        }
    case '*':
    case '/':
        switch (temp2)
        {
        case '+':
        case '-':
        case '=':
        case '(':
            return '>';
            break;
        case '*':
        case '/':
        case ')':
            return '<';
            break;
        default:
            printf("\n优先级比较错误!");
            exit(-1);
        }
    case '(':
        switch (temp2)
        {
        case '+':
        case '-':
        case '*':
        case '/':
        case '(':
            return '>';
            break;
        default:
            printf("\n优先级比较错误!");
            exit(-1);
        }
    case ')':
        switch (temp2)
        {
        case '+':
        case '-':
        case '*':
        case '/':
            return '<';
            break;
        case '(':
            return '=';
            break;
        default:
            printf("\n优先级比较错误!");
            exit(-1);
        }
    case '=':
        switch (temp2)
        {
        case '+':
        case '-':
        case '*':
        case '/':
        case '(':
            return '<';
            break;
        case '=':
            return '=';
            break;
        default:
            printf("\n优先级比较错误!");
            exit(-1);
        }
    default:
        printf("\n优先级比较错误!");
        exit(-1);
    }
}

int Operate(int a, char theta, int b)//返回二元运算 a theta b 的结果
{
    switch (theta)
    {
    case '+':
        return a + b;
        break;
    case '-':
        return a - b;
        break;
    case '*':
        return a * b;
        break;
    case '/':
        if (b == 0)
        {
            printf("\n分母不能为0!");
            exit(-1);
        }
        return a / b;
        break;
    default:
        printf("\n二元运算错误!");
        exit(-1);
    }
}