算术表达式求值

题目：只有整数和+-*/四种运算组成的算术表达书，实现其求值

参考：严蔚敏《数据结构》

 

#include "stack.h"

int In(ElemType c)
{
    switch(c)
    {
        case '+':
        case '-':
        case '*':
        case '/':
        case '(':
        case ')':
        case '#': return TRUE;
        default : return FALSE;
    }
}

ElemType operate(ElemType a, ElemType op, ElemType b)
{
    ElemType c;
    a -= 48;
    b -= 48;
    switch(op)
    {
        case '+': c=a+b+48;
                  break;
        case '-': c=a-b+48;
                  break;
        case '*': c=a*b+48;
                  break;
        case '/': c=a/b+48;
    }

    return c;
}

ElemType precede(ElemType t1, ElemType t2)
{
    ElemType rt;
    switch(t2)
    {
        case '+':
        case '-':
            if(t1 == '(' || t1 == '#')
               rt = '<';
            else
                rt = '>';
            break;
        case '/':
        case '*':
            if(t1 == ')' || t1 == '*' || t1 == '/')
               rt = '>';
            else
               rt = '<';
            break;
        case '(':
            rt = '<';
            break;
        case ')':
            if(t1 == '(')
               rt = '=';
            else
                rt = '>';
            break;
        case '#':
            if(t1 == '#')
                rt = '=';
            else
                rt = '>';
            break;
    }
    return rt;
}

int evaluateExp(ElemType str[])
{
    Stack dataStack, opStack;
    ElemType a, b, c;
    initStack(&dataStack);
    initStack(&opStack);
    ElemType *walker = str;
    while(*walker != '\0')
    {
        if(*walker <= '9' && *walker >= '0'){
            pushStack(&dataStack, *walker);
            walker++;
        }
        else if(In(*walker))
        {
            if(stackLength(opStack) == 0){
                pushStack(&opStack, *walker);
                walker++;
            }
            else
            {
                getTop(&opStack, &c);
                switch(precede(c, *walker))
                {
                    case '<':
                        pushStack(&opStack, *walker);
                        walker++;
                        break;
                    case '=':
                        popStack(&opStack, &c);
                        //walker++;
                        break;
                    case '>':
                        popStack(&opStack, &c);
                        popStack(&dataStack, &a);
                        popStack(&dataStack, &b);
                        c = operate(b, c, a);
                        pushStack(&dataStack, c);
                        break;
                }
            }
        }
    }

    getTop(&dataStack, &c);

    return c;
}
int main()
{
    char str[] = "#1+2*3-1#";
    printf("%d", evaluateExp(str)-48);
    return 0;
}

其中stack.h见下：

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <malloc.h>


#define STACK_INIT_SIZE 10
#define STACK_INCREMENT 2
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Boolean;
typedef char ElemType;
typedef struct Stack
{
    ElemType *base;
    ElemType *top;
    int      stacksize;
}Stack;

int initStack(Stack *S)
{
    S->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if(!S->base)
        exit(-2);
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}

int destroyStack(Stack *S)
{
    free(S->base);
    S->base = NULL;
    S->top = NULL;
    S->stacksize = 0;
    return OK;
}

int clearStack(Stack *S)
{
    S->top = S->base;
    return OK;
}

int stackEmpty(Stack *S)
{
    if(S->top == S->base)
        return TRUE;
    else
        return FALSE;
}

int stackLength(Stack S)
{
    return S.top-S.base;
}

int getTop(Stack *S, ElemType *c)
{
    if(S->top > S->base)
    {
        *c = *(S->top - 1);
        return OK;
    }
    else
        return ERROR;
}

int pushStack(Stack *S, ElemType c)
{
    if((S->top - S->base) > S->stacksize)
    {
        S->base = (ElemType *)realloc(S->base, S->stacksize+STACK_INCREMENT*sizeof(ElemType));
        if(!S->base)
            exit(-2);
        S->top = S->base + S->stacksize;
        S->stacksize += STACK_INCREMENT;
    }

    *(S->top++) = c;
    return OK;
}

int popStack(Stack *S, ElemType *c)
{
    if(S->top == S->base)
        return ERROR;
    *c = *(S->top - 1);
    S->top--;
    return OK;
}

#endif // STACK_H_INCLUDED