华为软件编程题：简单的四则运算

/* calculate.cpp
 * 问题描述：
 * 输入一个只包含个位数字的简单四则运算表达式字符串，
 * 计算该表达式的值
 * 注：
 * 1、表达式只含 +, -, *, / 四则运算符，不含括号
 * 2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
 * 3、要考虑加减乘除按通常四则运算规定的计算优先级
 * 4、除法用整数除法，即仅保留除法运算结果的整数部分。
 * 比如8/3=2。输入表达式保证无0作为除数情况发生
 * 5、输入字符串一定是符合题意合法的表达式，
 * 其中只包括数字字符和四则运算符字符，
 * 除此之外不含其它任何字符，不会出现计算溢出情况
 * 要求实现函数：int calculate(int len,char *expStr) 
 * 【输入】
 * int len: 字符串长度；
 * char *expStr: 表达式字符串；
 * 【输出】无
 * 【返回】
 * 计算结果
 * 示例
 * 1）输入：char *expStr = “1+4*5-8/3”
 * 函数返回：19 
 * 2）输入：char *expStr = “8/3*3”
 * 函数返回：6
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stack>

//判断运算符的优先级函数
int Precede(char a, char b)
{
    switch (a)
    {
        case '*':
        case '/':
            if ((b == '+') || (b == '-'))
            {
                return 1;    //a的优先级高于b
            }
            else
            {
                return 0;    //a的优先级等于b
            }
        case '+':
        case '-':
            if ((b == '*') || (b == '/'))
            {
                return -1;    //a的优先级低于b
            }
            else 
            {
                return 0; 
            }
        default:
            printf("运算符错误！
"); 
            break; 
    }
}

int Operate(int j, int k, char operater)
{
    //int temp = 0; 
    switch (operater)
    {
        case '+':
            return k + j; 
            //break; 
        case '-':
            return k - j; 
            //break; 
        case '*':
            return k * j; 
            //break; 
        case '/':
            //temp = k / j; 
            return k / j; 
            //break; 
        default:
            printf("运算错误！
"); 
            break; 
    }
}

int calculate(int len, char *expStr)
{
    //表达式异常处理，注意len <= 0要加括号
    if ((len <= 0 ) || (expStr == NULL))
    {
        printf("表达式为空！
"); 
    }

    int i = 0, j = 0, k = 0; 
    std::stack<int> date; 
    std::stack<char> operate; 

    while (i < len)
    {
        if ((expStr[i] >= '0') && (expStr[i] <= '9'))
        {
            date.push(expStr[i] - '0'); 
            i++; 
        }
        else if ((expStr[i] == '+') || (expStr[i] == '-') 
            || expStr[i] == '*' || expStr[i] == '/')
        {
            if (operate.empty())
            {
                operate.push(expStr[i]); 
                i++; 
            }
            else
            {
                //与栈顶运算符判断优先级
                switch (Precede(expStr[i], operate.top()))
                {
                    case 0:
                    case -1:    //栈顶运算符优先级高
                        j = date.top();
                        date.pop(); 
                        k = date.top(); 
                        date.pop(); 
                        //date.push(Operate(j, k , expStr[i])); 
                        date.push(Operate(j, k , operate.top())); 
                        operate.pop(); 
                        //i++; 
                        break; 
                    //case 0:
                    case 1:        //栈运算符顶优先级低
                        operate.push(expStr[i]); 
                        i++; 
                        break; 
                    default:
                        printf("优先级判断错误！
"); 
                        break; 
                }
            }
        }
        else
        {
            printf("表达式无法识别！
"); 
            break; 
        }
    }

    while (!operate.empty())
    {
        j = date.top(); 
        date.pop(); 
        k = date.top(); 
        date.pop(); 
        date.push(Operate(j, k , operate.top())); 
        operate.pop(); 
    }

    return date.top(); 
}

int main()
{
    int len = 0; 
    int i= 0, input_flag = 0; 
    
    //为了提高程序的鲁棒性，写了下面一段循环
    //此处关键是flushall()的使用，如果不使用
    //由于键盘输入缓存的存在使得程序陷入死循环
    //关于flush()参见我的下一篇博客
    while (!input_flag)
    {
        printf("请输入表达式的长度："); 
        input_flag = scanf("%d", &len); 
        if (!input_flag)
        {
            printf("输入有误，仅可输入数字！
"); 
            //flushall(); 
        }
        flushall(); 
    }

    char *expStr = (char *)malloc(len  * sizeof(char)); 
    input_flag = 0; 
    while (!input_flag)
    {
        printf("请输入表达式："); 
        for (i = 0; i < len; i++)
        {
            input_flag = scanf("%c", &expStr[i]); 
            //scanf("%c", &expStr[i]); 
            /*if ((i < len) && (expStr[i] == '
'))
            {
                printf("长度不够，请重新输入："); 
                i = 0; 
            }*/
            if (!input_flag)
            {
                printf("表达式输入有误！
"); 
                flushall(); 
                break; 
            }
        }
    }

    printf("表达式的计算结果为：%d
", calculate(len, expStr)); 
    return 0; 
}

//#include <iostream>
//
//using namespace std; 
//
//int calculate(int len, char *expStr)
//{
//    //定义操作符栈
//    struct
//    {
//        char opdate[200]; 
//        int top; 
//    }opstack; 
//
//    //定义栈操作符
//    opstack.top = -1; 
//    int i = 0;    //遍历字符串的下标
//    int t = 0;    //当前后缀表达式的长度
//    char ch = expStr[i]; 
//    while (ch != '')
//    {
//        switch (ch)
//        {
//            case '+':
//            case '-':
//                while (opstack.top != -1)
//                {
//                    expStr[t] = opstack.opdate[opstack.top]; 
//                    opstack.top--; 
//                    t++; 
//                }
//                opstack.top++; 
//                opstack.opdate[opstack.top] = ch; 
//                break; 
//            case '*':
//            case '/':
//                while (opstack.top != -1 && 
//                    (opstack.opdate[opstack.top] == '*' || 
//                    opstack.opdate[opstack.top] == '/'))
//                {
//                    expStr[t] = opstack.opdate[opstack.top]; 
//                    opstack.top--; 
//                    t++; 
//                }
//                opstack.top++; 
//                opstack.opdate[opstack.top] = ch; 
//                break; 
//            default:
//                expStr[t] = ch; 
//                t++; 
//                break; 
//        }
//        i++; 
//        ch = expStr[i]; 
//    }
//
//    while (opstack.top != -1)    //将栈中所有剩余的运算符出栈
//    {
//        expStr[t] = opstack.opdate[opstack.top]; 
//        opstack.top--; 
//        t++; 
//    }
//    expStr[t] = ''; 
//
//    struct
//    {
//        int numeric[200]; 
//        int top; 
//    }date; 
//    date.top = -1; 
//    i = 0; 
//    ch = expStr[i]; 
//    while (ch != '')
//    {
//        if (ch >= '0' && ch <= '9')
//        {
//            date.top++; 
//            date.numeric[date.top] = ch - '0'; 
//        }
//        else if ('+' == ch)
//        {
//            int tmp = date.numeric[date.top - 1] + 
//                date.numeric[date.top]; 
//            date.top--; 
//            date.numeric[date.top] = tmp; 
//        }
//        else if ('-' == ch)
//        {
//            int tmp = date.numeric[date.top - 1] - 
//                date.numeric[date.top]; 
//            date.top--; 
//            date.numeric[date.top] = tmp; 
//        }
//        else if ('*' == ch)
//        {
//            int tmp = date.numeric[date.top - 1] * 
//                date.numeric[date.top]; 
//            date.top--; 
//            date.numeric[date.top] = tmp; 
//        }
//        else if ('/' == ch)
//        {
//            if (date.numeric[date.top] == 0)
//            {
//                printf("cannot be zero of the divide
"); 
//                exit(1); 
//            }
//            int tmp = date.numeric[date.top - 1] / 
//                date.numeric[date.top]; 
//            date.top--; 
//            date.numeric[date.top] = tmp; 
//        }
//        i++; 
//        ch = expStr[i]; 
//    }
//    return date.numeric[date.top]; 
//}
//
//void main()
//{
//    char expStr[] = "9/3*5"; 
//    printf("%s
", expStr); 
//    int result = calculate(strlen(expStr), expStr); 
//    printf("%d", result); 
//}