3.22√ 对以波兰式表示的表达式求值

将就一下。。只做到了字符型向整型数值的转换，所以输出结果只有整型。。。。太烦了。。。。。

#include <stdio.h>
#define maxsize 100

typedef char Elemtype;

int compare_dominant(char a, char b)
{//比较运算符的优先级
    
    if(a == '+' || a == '-' && b == '/' || b == '*')
        return 0;
    if(a == '/' || a == '*' && b == '+' || b == '-')
        return 1;
    if(a == '+' || a == '-' && b == '+' || b == '-')
        return 0;
    if(a == '/' || a == '*' && b == '/' || b == '*')
        return 0;
}
    
void trans_post_exp(char exp[], char newexp[])
{//将中缀表达式（已存储在数组中）转换成后缀表达式，将后缀表达式存储在另一个数组中；

    int i=0;
    char stack[maxsize]; int top = -1;
    

    for(int k=0; exp[k] != '#'; k++)
    {   
        //扫描到左括号，则直接入栈
        if(exp[k] == '(')      
            stack[++top] = exp[k];
            
        //若扫描到右括号，则令栈顶元素出栈，并存入新数组中
        else if(exp[k] == ')' && top != -1)
        {
            newexp[i++] = stack[top--];
            if(stack[top] == '(')
                    top--;
        }
            
        //若扫描到字母，则直接存入新数组中；
        else if(exp[k] != '+' && exp[k] != '-' && exp[k] != '/' && exp[k] != '*')
            newexp[i++] = exp[k];
            
        //若扫描到运算符，则将其与栈顶运算符比较优先级，如果新运算符优先级较高，将其入栈，
        //否则栈顶元素出栈并入新数组，再将新运算符入栈
        else
        {
            if(top == -1 || stack[top] == '(')   //栈空或者栈顶元素为左括号时直接入栈
                stack[++top] = exp[k];
                
            else if(compare_dominant(exp[k], stack[top]) == 1)
                stack[++top] = exp[k];
                
            else        //新运算符优先级不高于栈顶元素时，一直出栈，直到新运算符优先级高于栈顶元素
            {
                while(compare_dominant(exp[k], stack[top]) == 0 && top != -1)
                    newexp[i++] = stack[top--];
                stack[++top] = exp[k];
            }
            
        }
    }

    while(top != -1 )
    {
        if(stack[top] != '(')
            newexp[i++] = stack[top];
        top--;
    }
        
    
}

void print(char exp[])
{
    for(int i=0; exp[i] != '#'; i++)
        printf("%c", exp[i]);
}

int operate(char a, char b, char op)
{
    if(op == '+')
        return (a-'0')+(b-'0');
    if(op == '-')
        return (a-'0')-(b-'0');
    if(op == '/')
        return (a-'0')/(b-'0');
    if(op == '*')
        return (a-'0')*(b-'0');
}

void compute(Elemtype exp[])
{//计算后缀表达式的值,建立两个辅助栈，栈1用来存储数值，栈2用来存储运算符
//算法思想：扫描整个表达式数组，遇到数值直接入栈，遇到运算符，将其与栈2栈顶运算符比较优先级；
//若新运算符的优先级较高，则取出栈2两个连续的数值，计算他们的表达式值，并将其入栈1

    Elemtype stack1[maxsize];   int top1 = -1;      //用于保存数值
    Elemtype stack2[maxsize];   int top2 = -1;      //用于保存运算符
    
    for(int i=0; exp[i] != '#'; i++)
    {//扫描整个表达式数组
        
        //若扫描到数值，入栈1
        if(exp[i] != '+' && exp[i] != '-' && exp[i] != '/' && exp[i] != '*')
            stack1[++top1] = exp[i];
        
        //若扫描到运算符，比较优先级
        else 
        {
            if(top2 = -1)
            {
                char op = exp[i];
                float b = stack1[top1--];
                float a = stack1[top1--];
                stack1[++top1] = operate(a, b, op);
            }
            else if(exp[i] == '/' || exp[i] == '*' && stack2[top2] == '+' || stack2[top2] == '-')
            {
                char op = exp[i];
                float b = stack1[top1--];
                float a = stack1[top1--];
                stack1[++top1] = operate(a, b, op);
            }
            else
            {
                char op = stack2[top2--];
                float b = stack1[top1--];
                float a = stack1[top1--];
                stack1[++top1] = operate(a, b, op);
                printf("测试值%d\n",stack1[top1]);

            }
        }
    }
    printf("表达式的结果为：%d", stack1[top1]);
}

int main()
{
    Elemtype exp[maxsize];
    Elemtype x; int i=0;
    printf("请输入正确的表达式：\n");
    
    while(x != '#')
    {
        x = getchar();
        exp[i++] = x;
    }
    getchar();  //用于接收回车键
    
    Elemtype newexp[maxsize];
    for(int i=0; i<maxsize; i++)
        newexp[i] = '#';
    trans_post_exp(exp, newexp);
    
    print(newexp);
    
    compute(newexp);
    

    return 0;
}