Evaluate Reverse Polish Notation

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Some examples:

  ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
  ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

#define MAX_LENGTH 10000

int string2int(char * s) {
    int res = 0;
    int is_positive = 1;
    if (*s == '-'){
        is_positive = 0;
        ++s;
    } else if (*s == '+') {
        ++s;
    }
    
    while(*s){
        res = res * 10 + *s - '0';
        ++s;
    }
    if (is_positive == 0) {
        res = -res;
    }
    return res;
}

int string_equal(char *s1, char *s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    if (len1 != len2) {
        return 0;
    }
    int i;
    for (i = 0; i < len1; ++i) {
        if (s1[i] != s2[i]) {
            return 0;
        }
    }
    return 1;
}


int evalRPN(char** tokens, int tokensSize) {
    if (tokensSize == 0) {
        return 0;
    }
    
    int stack[MAX_LENGTH];
    int len_stack = 0;
    int index = 0;
    
    stack[len_stack++] = string2int(tokens[index++]);
    int res = stack[len_stack - 1];
    
    int v1, v2;
    while(len_stack != 0) {
        while(index < tokensSize && !string_equal(tokens[index], "+") && !string_equal(tokens[index], "-") && !string_equal(tokens[index], "*") && !string_equal(tokens[index], "/")) {
            stack[len_stack++] = string2int(tokens[index++]);
        }
        if (index < tokensSize) {
            v2 = stack[--len_stack];
            v1 = stack[--len_stack];
            switch(tokens[index][0]) {
                case '+':
                    res = v1 + v2;
                    break;
                case '-':
                    res = v1 - v2;
                    break;
                case '*':
                    res = v1 * v2;
                    break;
                case '/':
                    res = v1 / v2;
                    break;
                default:
                    break;
            }
            stack[len_stack++] = res;
            ++index;
        }
        
        if (index == tokensSize && len_stack == 1) {
            break;
        }
    }
    return res;
}

版本二：

#define MAX_LENGTH 10000


int evalRPN(char** tokens, int tokensSize) {
    if (tokensSize == 0) {
        return 0;
    }
    
    int * stack = (int *) malloc(sizeof(int) * MAX_LENGTH);
    int top = -1;
    
    int i;
    int v2;
    int v1;
    int res;
    
    for (i = 0; i < tokensSize; ++i) {
        if (tokens[i][1] == '\0') {
            if (tokens[i][0] < '0'  || tokens[i][0] > '9') {
                v2 = stack[top--];
                v1 = stack[top--];
                switch (tokens[i][0]) {
                    case '+':
                        res = v1 + v2;
                        break;
                    case '-':
                        res = v1 - v2;
                        break;
                    case '*':
                        res = v1 * v2;
                        break;
                    case '/':
                        res = v1 / v2;
                        break;
                }
            } else {
                res = tokens[i][0] - '0';
            }
            stack[++top] = res;
        } else {
            stack[++top] = atoi(tokens[i]);
        }
    }
    
    assert(top == 0);
    res = stack[top];
    free(stack);
    stack = NULL;
    return res;
}

自己有时好蠢。。。