leetcode 150. 逆波兰表达式求值

易错点！！！

1. 转换数值时切记在返回时输出符号！！！
2. 栈是逆序的！！！第一个栈顶元素作为第二个运算数，第二个栈顶元素作为首个运算数

tips：

1. 若字符串首个元素是“-”且字符串长度＞1，可以判断为负数
2. 链栈结构与单链表结点相同，可以用typedef为stack和linkNode两种名称做区分
3. 四则运算时，取栈顶两个操作数和压入运算结果是共用操作，可以分别放在swich外部的首尾；分支结构进行各自运算即可

原题：

有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

• 整数除法只保留整数部分。
• 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

输入: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
输出: 22
解释: 
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

*
1.判断数字或操作符的函数bool isDigital(char**)
2.字符转化为数值的函数int shift(char**)
3.建立链栈
4.两个临时变量tmp1,tmp2，用以接收并计算栈顶两个数值
*/
//#include "ADT.h"

bool isDigital(char* str)
{
        if(*str >= '0' && *str <= '9')
                return true;
        if(*str == '-' && strlen(str) > 1 )
                return true;

        return false;
}

int shiftToDigital(char* str)
{
        int sign = 1;//符号标志
        int result = 0;//存储计算结果
        int i = 0; //用以遍历字符串

        if (*str == '-')
        {
                sign = -1;
                i = 1;//若是负数负号标志置-1，且从第二个元素开始
        }

        for (; str[i]; ++i )
                result = result * 10 + (str[i] - '0');

        //Error!!!判断符号！！！
        return sign*result;
}

//建立链栈-链点并重命名stack&node,初始化，判空，出入栈，取栈顶
typedef struct linkNode{
        int num;
        struct linkNode *next;
} linkNode, stack;

void initialStack(stack* s)
{
        s->num = 0;//记录栈的有效结点数
        s->next = NULL;
}

bool isEmpty(stack *s)
{
        return s->next == NULL;
}

bool push(stack *s , int n)
{
        linkNode *new = (linkNode *)malloc(sizeof(linkNode));
        if( !new )
                return false;

        new->num = n;
        new->next = s->next;
        s->next = new;
        ++s->num;

        return true;
}

bool pop(stack *s,int *tmp)
{
        if(isEmpty(s))
                return false;
        *tmp = s->next->num;
        s->next = s->next->next;
        return true;
}

int getTop(stack *s)
{
        return s->next->num;
}

bool destroy(stack *s)
{
        free(s->next);
        free(s);
        return true;
}

//四则运算函数
//Error!!!栈顶两个元素是逆序的！！！运算中第二个栈顶元素应该放前面
void calculate(char* sign,stack *s)
{
        int tmp1 = 0;
        int tmp2 = 0;
        //切记，先取的元素是第二个运算数
        pop(s,&tmp2);
        pop(s,&tmp1);

        switch (*sign)
        {
                case '+':
                        tmp1 += tmp2;
                        break;
                case '-':
                        tmp1 -= tmp2;
                        break;
                case '*': 
                        tmp1 *= tmp2;
                        break;
                case '/':
                        tmp1 /= tmp2;
        }
        push(s, tmp1);
        return;
}

int evalRPN(char ** tokens, int tokensSize){
        //遍历字符串数组的指针 j，遍历字符串元素的指针 k; 存储转化后的数值tmp
        if (!tokensSize)
                return INT_MAX;

        int tmp = 0;
        stack *s = (stack *)malloc(sizeof(stack));
        if(!s)
                return INT_MAX;
        initialStack(s);

        for (int j = 0; j < tokensSize; ++j)
        {
                //字符子串若为数字，则转化为数值并压入栈中，否则判断运算符号并计算
                char *str = tokens[j];
                if (isDigital(str))
                {
                        tmp=shiftToDigital(str);
                        push(s, tmp);
                }
                else
                        calculate(str, s);
        }

        tmp = getTop(s);
        destroy(s);
        return tmp;
}