基于二叉树的表达式求值算法

#include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<ctype.h>

#define INIT_STACK_SIZE 100
#define INCREMENT 10 

typedef char TElemType;
typedef struct{
	TElemType *top,*base;
	int sizestack;
}SqStack;

typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreateStack(SqStack *S){
	S->top=S->base=(char*)malloc(sizeof(char)*INIT_STACK_SIZE);
	if(!S->base)exit(-1);
	S->sizestack=INIT_STACK_SIZE;
}

int isEmpty(SqStack *S){
	return S->top==S->base;//empty=1,noempty=0
}

int isFull(SqStack *S){
	return S->top-S->base==S->sizestack;//full=1,nofull=0
}

void Push(SqStack *S,char ch){
	if(isFull(S)){
		char* newbase=(char*)realloc(S->base,
		sizeof(char)*(S->sizestack+INCREMENT));
		if(!newbase)exit(-1);
		S->base=newbase;
		S->top=S->base+S->sizestack;
		S->sizestack+=INCREMENT;
	}
	*S->top++=ch;
}

char Pop(SqStack *S){
	if(!isEmpty(S))return *--S->top;
	else return NULL;
}

char GetTop(SqStack *S){
	if(!isEmpty(S))return *(S->top-1);
	else return NULL;
} 

typedef struct{
	BiTree *top,*base;
	int sizestack;
}SqStack_BiTree;

void CreateStack_BiTree(SqStack_BiTree *SB){
	SB->top=SB->base=(BiTree*)malloc(sizeof(BiTree)*INIT_STACK_SIZE);
	if(!SB->base)exit(-1);
	SB->sizestack=INIT_STACK_SIZE;
}

int isEmpty_BiTree(SqStack_BiTree *SB){
	return SB->top==SB->base;//empty=1,noempty=0
}

int isFull_BiTree(SqStack_BiTree *SB){
	return SB->top-SB->base==SB->sizestack;//full=1,nofull=0
}

void Push_BiTree(SqStack_BiTree *SB,BiTree T){
	if(isFull(SB)){
		char* newbase=(char*)realloc(SB->base,
		sizeof(BiTree)*(SB->sizestack+INCREMENT));
		if(!newbase)exit(-1);
		SB->base=newbase;
		SB->top=SB->base+SB->sizestack;
		SB->sizestack+=INCREMENT;
	}
	*SB->top++=T;
}

BiTree Pop_BiTree(SqStack_BiTree *SB){
	if(!isEmpty(SB))return *--SB->top;
	else return NULL;
}

BiTree GetTop_BiTree(SqStack_BiTree *SB){
	if(!isEmpty(SB))return *(SB->top-1);
	else return NULL;
} 

// 获取运算符优先级
int getPriority(char op) {
    switch (op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;  // 对于数字，括号等非运算符，返回0表示无关紧要的优先级
    }
}

// 将中缀表达式转换为后缀表达式
void infixToPostfix(char infix[], char postfix[]){
	SqStack S; CreateStack(&S);
	int i=0,j=0;
	while(infix[i]!='='){
		if(isalnum(infix[i]))postfix[j++]=infix[i];
		else if(infix[i]=='(')Push(&S,infix[i]);
		else if(infix[i]==')'){
			while(!isEmpty(&S)&&GetTop(&S)!='(')postfix[j++]=Pop(&S);
			Pop(&S);
		}
		else {
			while(!isEmpty(&S)&&getPriority(GetTop(&S))>=getPriority(infix[i])){
				postfix[j++]=Pop(&S);
			}
			Push(&S,infix[i]);
		}
		i++;
	}
	
	while(!isEmpty(&S))postfix[j++]=Pop(&S);
	postfix[j]='\0';
}


// 利用栈构建表达式树
BiTree CreateSBiTree(char postfix[]) {
    SqStack_BiTree SB; CreateStack_BiTree(&SB);
    int i = 0;
    while (postfix[i] != '\0') {
        if (isalnum(postfix[i])) {
            // 如果是操作数，直接入栈
            BiTree T = (BiTree)malloc(sizeof(BiTNode));
            T->data = postfix[i];
            T->lchild = T->rchild = NULL;
            Push_BiTree(&SB, T);
        } else {
            // 如果是运算符，弹出两个操作数节点，构建新的树节点，再入栈
            BiTree T = (BiTree)malloc(sizeof(BiTNode));
            T->data = postfix[i];
            T->rchild = Pop_BiTree(&SB);
            T->lchild = Pop_BiTree(&SB);
            Push_BiTree(&SB, T);
        }
        i++;
    }
    // 最终栈中只剩下一个树节点，即根节点
    return Pop_BiTree(&SB);
}

void postOrder(BiTree T) {
    if (T) {
        postOrder(T->lchild);
        postOrder(T->rchild);
        printf("%c", T->data);
    }
}

int postOrderTraversalAndEvaluate(BiTree T) {
    if (T) {
        int leftValue = postOrderTraversalAndEvaluate(T->lchild);
        int rightValue = postOrderTraversalAndEvaluate(T->rchild);

        switch (T->data) {
            case '+': return leftValue + rightValue;
            case '-': return leftValue - rightValue;
            case '*': return leftValue * rightValue;
            case '/': return leftValue / rightValue;
            default: return T->data - '0';
        }
    }
    return 0;
}

int main(){

	char infix[100],postfix[100];
	int i=0,j=0;
	BiTree T[100];
	while (1) { 
		printf("请输入表达式（当输入只有一个 = 时，输入结束！）："); 
        scanf("%s", infix);
        if (infix[0] == '=')break;
        infixToPostfix(infix,postfix);
        T[i++]=CreateSBiTree(postfix);
    }
    printf("\n\n");
    while(j<i)printf("结果是：%d\n",postOrderTraversalAndEvaluate(T[j++]));
	return 0;
}