利用树求解算术表达式的值

利用树求解算术表达式的值

 

#include <stdio.h>
#include <string.h>
#include <malloc.h>
//#include "btree.h"
#define MaxSize 100
#include<stdlib.h>
typedef struct Node
{
    char data;
    struct Node *lchild;
    struct Node *rchild;
}BTNode,*BTree;
//用s[i]到s[j]之间的字符串，构造二叉树的表示形式
BTNode *CreateTree(char s[],int i,int j)
{
    BTNode *p;
    int k,plus=0,posi;
    if (i==j) //i和j相同，意味着只有一个字符，构造的是一个叶子节点
    {
        p=(BTNode *)malloc(sizeof(BTNode)); //分配存储空间
        p->data=s[i]; //值为s[i]
        p->lchild=NULL;
        p->rchild=NULL;
        return p;
    }
    //以下为i!=j的情况
    for (k=i; k<=j; k++)
        if (s[k]=='+' || s[k]=='-')
        {
            plus++;
            posi=k; //最后一个+或-的位置
        }
        if (plus==0) //没有+或-的情况(因为若有+、-，前面必会执行plus++)
            for (k=i; k<=j; k++)
                if (s[k]=='*' || s[k]=='/')
                {
                    plus++;
                    posi=k;
                }
                //以上的处理考虑了优先将+、-放到二叉树较高的层次上
                //由于将来计算时，运用的是后序遍历的思路
                //处于较低层的乘除会优先运算
                //从而体现了“先乘除后加减”的运算法则
                //创建一个分支节点，用检测到的运算符作为节点值
                if (plus!=0)
                {
                    p=(BTNode *)malloc(sizeof(BTNode));
                    p->data=s[posi]; //节点值是s[posi]
                    p->lchild=CreateTree(s,i,posi-1); //左子树由s[i]至s[posi-1]构成
                    p->rchild=CreateTree(s,posi+1,j); //右子树由s[poso+1]到s[j]构成
                    return p;
                }
                else //若没有任何运算符，返回NULL
                    return NULL;
}

int find_split(char express[], int start, int end)
{
    int tag = -1;

    if (express[start] == '(' && express[end] == ')')
    {
        ++start;
        --end;
    }

    int is_in_braket = 0;
    int more_grade = 0;
    for (int i = start; i <= end; i++)
    {
        if (express[i] == '(')
            ++is_in_braket;
        else if (express[i] == ')')
            --is_in_braket;

        if ((express[i] == '+' || express[i] == '-')
            && is_in_braket == 0)
        {
            more_grade = 1;
            tag = i; //无break, 找最后一个符合条件的运算符, 取顶级的+和-
        }
        else if ((express[i] == '*' || express[i] == '/')
            && more_grade == 0
            && is_in_braket == 0)
        {
            tag = i; //无break, 找最后一个符合条件的运算符
        }
    }
    return tag;
}

BTree Creat_Btree( char *express, int start, int end)
{
    BTree pTree = NULL;

    if (start == end)
    {
        pTree = (BTree)malloc(sizeof(BTNode));
        pTree->data = express[start];
        pTree->lchild = NULL;
        pTree->rchild = NULL;
    }
    else
    {   //递归调用, 各自创建左右的表达式的对应二叉树
        int tag = find_split(express, start, end);
        if (tag < 0)
        {
            printf("1.invalid express, exit.\n");
            exit(-1);
        }
        else
        {
            pTree = (BTree)malloc(sizeof(BTNode));
            pTree->data = express[tag];
        }
        if (express[start] == '(' && express[end] == ')')
        {
            ++start;
            --end;
        }
        pTree->lchild = Creat_Btree(express, start, tag - 1);
        pTree->rchild = Creat_Btree(express, tag + 1, end);
    }
    return pTree;
}
double post_traverser_calc(BTree pTree)
{
    if (pTree == NULL)
        return -1;
    else if ('0' <= pTree->data &&pTree->data <= '9')
        return pTree->data - '0';
    else if(pTree->data=='+')
        return post_traverser_calc(pTree->lchild) + post_traverser_calc(pTree->rchild);
    else if(pTree->data=='-')
        return post_traverser_calc(pTree->lchild) - post_traverser_calc(pTree->rchild);
    else if(pTree->data=='*')
        return post_traverser_calc(pTree->lchild) * post_traverser_calc(pTree->rchild);
    else if(pTree->data=='/')
        return post_traverser_calc(pTree->lchild) / post_traverser_calc(pTree->rchild);
}

double CalcuValue(BTNode *b)
{
    double v1,v2;
    if (b==NULL)
        return 0;
    if (b->lchild==NULL && b->rchild==NULL) //叶子节点，应该是一个数字字符（本项目未考虑非法表达式）
        return b->data-'0'; //叶子节点直接返回节点值，结点中保存的数字用的是字符形式，所以要-'0'
    v1=CalcuValue(b->lchild); //先计算左子树
    v2=CalcuValue(b->rchild); //再计算右子树
    switch(b->data) //将左、右子树运算的结果再进行运算，运用的是后序遍历的思路
    {
    case '+':
        return v1+v2;
    case '-':
        return v1-v2;
    case '*':
        return v1*v2;
    case '/':
        if (v2!=0)
            return v1/v2;
        else
            abort();
    }
}
void TreePrint(BTree T,int level) 
/*按树状打印的二叉树*/ 
{   
    int i;
    if(T==NULL)                    /*如果指针为空，返回上一层*/ 
        return;
    TreePrint(T->rchild,level+1);/*打印右子树，并将层次加1*/ 
    for(i=0;i<level;i++)            /*按照递归的层次打印空格*/ 
        printf("   ");
    printf("%c\n",T->data);        /*输出根结点*/ 
    TreePrint(T->lchild,level+1);/*打印左子树，并将层次加1*/ 
}
void DestroyBTree(BTree *T)
/*销毁二叉树操作*/
{
    if(*T)                             /*如果是非空二叉树*/
    {
        if((*T)->lchild)
            DestroyBTree(&((*T)->lchild));
        if((*T)->rchild)
            DestroyBTree(&((*T)->rchild));
        free(*T);
        *T=NULL;
    }
}
int main()
{
    BTNode *b;
    char s[MaxSize]="1+2*3-4/5";
    printf("算术表达式%s\n",s);
    /*
    b=CreateTree(s,0,strlen(s)-1);

    printf("对应二叉树:\n");
    TreePrint(b,0);
    printf("\n表达式的值:%g\n",CalcuValue(b));
    DestroyBTree(&b);
    */

    double result=0;
    BTree express_tree = Creat_Btree(s, 0, strlen(s)-1);
    result=post_traverser_calc(express_tree);
    printf("后缀表达式：");
    post_traverser_calc(express_tree);
    printf("\n");
    printf("表达式结果为：%.2f\n", result);

    return 0;
}