C实现将中缀算术式转换成后缀表达式

#include "stdio.h"
#include "stdlib.h"
#include "ctype.h"
#include "math.h"
#include "string.h"

struct stackNode{
    char data;
    int value;
    struct stackNode *nextPtr;
};

typedef struct stackNode StackNode;
typedef StackNode *StackNodePtr;

int isOperator(char c);
void convertToPostfix(char infix[],char postfix[]);
int precedence(char opt1,char opt2);
void push(StackNodePtr *topPtr, char value);
char pop(StackNodePtr *topPtr);
void push2(StackNodePtr *topPtr, int value);
int pop2(StackNodePtr *topPtr);
char stackTop(StackNodePtr topPtr);
int isEmpty(StackNodePtr topPtr);
void printStack(StackNodePtr topPtr);
int calculate(int val1, int val2, char opt);
int evaluatePostfixExp(char postfix[]);

int main(void)
{
    int i=0;
    char ch;
    char infix[100];
    char postfix[100];

    printf("Enter the expression:
");

    while((ch = getchar()) != '
'){
        if(ch != ' '){
            if(isdigit(ch)){
                infix[i++] = ch; 
            }
            else if(isOperator(ch)){
                infix[i++] = ' ';
                infix[i++] = ch; 
                infix[i++] = ' ';
            }else if(ch == '('){
                    infix[i++] = ch; 
                    infix[i++] = ' ';
            }else{
                infix[i++] = ' ';
                infix[i++] = ch; 
            }
        }
    }
    infix[i] = ''; 
    
    printf("the infix:
%s
",infix);
    convertToPostfix(infix,postfix);
    printf("the postfix:
%s
",postfix);

    printf("result:%d
",evaluatePostfixExp(postfix));
    getchar();
    return 0;
}

/*是否为操作符*/
int isOperator(char c)
{
    switch(c){
        case '+':
        case '-':
        case '*':
        case '/':
        case '^':
            return 1;break;
        default:
            return 0;break;
    }
}

/*转换成后缀表达式*/
void convertToPostfix(char infix[],char postfix[])
{
    int i,j=0;
    char *strPtr;
    char popValue;
    StackNodePtr stackPtr =NULL;

    strPtr = strtok(infix, " ");
    while(strPtr){
        if(isdigit(strPtr[0])){
            if(j>0 ){
                postfix[j++] = ' ';
            }
            while(*strPtr !=  ''){
                postfix[j++] = *strPtr;
                strPtr++;
            }
        }else if(strPtr[0] == '('){
            push(&stackPtr,'(');
            printStack(stackPtr);
        }else if(strPtr[0] == ')'){//遇到右括号，必须把对应左括号前的运算符都弹出
            while((popValue = pop(&stackPtr)) != '(' ){
                postfix[j++] = ' ';
                postfix[j++] = popValue;
                printStack(stackPtr);
            }
        }else if(isOperator(strPtr[0])){
            int flag = 1;
            char tmpCH;
            while(flag){//这里必须判断栈里是否还有运算符优先级比当前运算符高的
                tmpCH = stackTop(stackPtr);
                if(tmpCH == '(' || tmpCH == '0'){
                    push(&stackPtr,strPtr[0]);
                    printStack(stackPtr);
                    flag = 0;
                }else{
                    if(precedence(strPtr[0],tmpCH) > 0){
                        postfix[j++] = ' ';
                        postfix[j++] = pop(&stackPtr);
                        printStack(stackPtr);
                    }else{
                        push(&stackPtr,strPtr[0]);
                        printStack(stackPtr);
                        flag = 0;
                    }
                }
            }
        }
        strPtr = strtok(NULL, " ");
    }
    while(!isEmpty(stackPtr)){//栈里如果还有运算符就弹出
        postfix[j++] = ' ';
        postfix[j++] = pop(&stackPtr);
        printStack(stackPtr);
    }
/*    for(i = 0; infix[i] != ''; i++){
        if(isOperator(infix[i])){
            char tmpCH = stackTop(stackPtr);
            if(tmpCH == '(' || tmpCH == '0'){
                push(&stackPtr,infix[i]);
                printStack(stackPtr);
            }else{
                if(precedence(infix[i],tmpCH) > 0){
                    postfix[j++] = pop(&stackPtr);
                    push(&stackPtr,infix[i]);
                    printStack(stackPtr);
                }else{
                    push(&stackPtr,infix[i]);
                    printStack(stackPtr);
                }
            }
        }else if(infix[i] == '('){
            push(&stackPtr,infix[i]);
            printStack(stackPtr);
        }else if(infix[i] == ')'){
            while((popValue = pop(&stackPtr)) != '(' ){
                postfix[j++] = popValue;
                printStack(stackPtr);
            }
        }else if(isdigit(infix[i])){
            postfix[j++] = infix[i];
        }
    }
    while(!isEmpty(stackPtr)){
        postfix[j++] = pop(&stackPtr);
        printStack(stackPtr);
    }
    */
    postfix[j] = '';
}

/*优先级的判断*/
int precedence(char opt1,char opt2)
{
    switch(opt1){
        case '+':
        case '-':if(opt2 == '+' || opt2 == '-'){
                    return 0;
                 }else{
                    return 1;
                 }
                 break;
        case '*':
        case '/':
        case '^':
        case '%':if(opt2 == '+' || opt2 == '-'){
                    return -1;
                 }else{
                    return 0;
                 }
                 break;
        default:
            printf("unvalid operator.
");
            break;
    }
}

void push(StackNodePtr *topPtr, char value)
{
    StackNodePtr newPtr;
    newPtr = (StackNodePtr)malloc(sizeof(StackNode));
    if(newPtr != NULL){
        newPtr->data = value;
        newPtr->nextPtr = *topPtr;
        *topPtr = newPtr;    
    }else{
        printf("call for memeory is failed!
");
    }
}

void push2(StackNodePtr *topPtr, int value)
{
    StackNodePtr newPtr;
    newPtr = (StackNodePtr)malloc(sizeof(StackNode));
    if(newPtr != NULL){
        newPtr->value = value;
        newPtr->nextPtr = *topPtr;
        *topPtr = newPtr;    
    }else{
        printf("call for memeory is failed!
");
    }
}

char pop(StackNodePtr *topPtr)
{
    char value;
    StackNodePtr tmpPtr;
    tmpPtr = *topPtr;
    value = (*topPtr)->data;
    *topPtr = (*topPtr)->nextPtr ; 
    free(tmpPtr);
    return value;
}

int pop2(StackNodePtr *topPtr)
{
    int value;
    StackNodePtr tmpPtr;
    tmpPtr = *topPtr;
    value = (*topPtr)->value;
    *topPtr = (*topPtr)->nextPtr ; 
    free(tmpPtr);
    return value;
}

char stackTop(StackNodePtr topPtr)
{
    if(!isEmpty(topPtr)){
        return topPtr->data;
    }else{
        return '0';
    }
}

int isEmpty(StackNodePtr topPtr)
{
    return topPtr==NULL;
}

void printStack(StackNodePtr topPtr)
{
    if(topPtr){
        while(topPtr){
            printf("%c",topPtr->data);
            topPtr = topPtr ->nextPtr;
        }
        printf("NULL
");
    }else{
        printf("this stack is empty.
");
    }
}

int evaluatePostfixExp(char postfix[])
{
    int i;
    int val1,val2;
    char *tokenPtr;
    StackNodePtr stackPtr = NULL;

    tokenPtr = strtok(postfix, " ");

    while(tokenPtr){
        if(isdigit(tokenPtr[0])){
            push2(&stackPtr,atoi(tokenPtr));
        }
        if(isOperator(tokenPtr[0])){
            val1 = pop2(&stackPtr) ;
            val2 = pop2(&stackPtr) ;
            push2(&stackPtr,calculate(val2,val1,tokenPtr[0]));
        }
        tokenPtr = strtok(NULL, " ");
    }
/*    for(i=0; postfix[i] != ''; i++){
        if(isdigit(postfix[i])){
            push(&stackPtr,postfix[i]);
        }
        if(isOperator(postfix[i])){
            val1 = pop(&stackPtr) - 48;
            val2 = pop(&stackPtr) - 48;
            push(&stackPtr,calculate(val2,val1,postfix[i]) +48);
        }
    }*/

    return pop2(&stackPtr);
}

int calculate(int val1, int val2, char opt)
{
    switch(opt){
        case '+':
            return val1 + val2;
            break;
        case '-':
            return val1 - val2;
            break;
        case '*':
            return val1*val2;
            break;
        case '/':
            return val1/val2;
            break;
        case '^':
            return (int)(pow((double)val1,val2));
            break;
        default:
            printf("operator is error!
");
    }
    return 0;
}