二叉树与表达式

#include <iostream>
#include <stdio.h>
using namespace std;
int result=0;
int flag=0;
class Bintree;//二叉树
class Binnode//节点类
{
    friend Bintree;
public:
    Binnode()//构造1
    {
        lchild=NULL;
        rchild=NULL;
    }
    Binnode(char d,Binnode *l=NULL,Binnode *r=NULL)//构造2
    {
        data=d;
        lchild=l;
        rchild=r;
    }
    ~Binnode() {} //析构
private:
    Binnode *lchild,*rchild;
    char data;
};
class seqstack;//栈
class Bintree
{
public:
    Bintree()
    {
        root=NULL;
    }
    ~Bintree()
    {
        destroy(root);
    }
    void createbintree()
    {
        createbintree(root);
    }
    Binnode *parent(Binnode *current)
    {
        return(root==NULL||root==current)?NULL:parent(root,current);


    }
    Binnode *Leftchild(Binnode *current)
    {
        return(current==NULL)?NULL:current->lchild;
    }
    void inoder()
    {
        inoder(root);
    }
    void postoder()
    {
        postoder(root);
    }
    void output1();
    void output2()//最终结果
    {
        cout<<result;
    }
private:
    Binnode *root;
    friend seqstack;
    seqstack *s;
    void createbintree(Binnode *&tree);
    Binnode *parent(Binnode *tree,Binnode *current);
    void inoder(Binnode *tree);
    void postoder(Binnode *tree);
    void destroy(Binnode *&tree);
};


class seqstack
{
private:
    char *element;
    int top;
public:
    seqstack()
    {
        element=new char[50];
        top=-1;
    }
    void push(char x)
    {
        element[++top]=x;
    }
    char pop()
    {
        char x=element[top--];
        return x;
    }
};


void Bintree::createbintree(Binnode *&node)
{
    s=new seqstack[50];
    char d;
    cin>>d;
    if(d!='@')
    {
        node=new Binnode(d);
        createbintree(node->lchild);
        createbintree(node->rchild);
    }
}


Binnode *Bintree::parent(Binnode *subtree,Binnode *current)
{
    if(subtree==NULL)
        return NULL;
    if(subtree->lchild==current||subtree->rchild==current)
    {
        return subtree;
    }
    return parent(subtree->lchild,current)==NULL?parent(subtree->rchild,current):parent(subtree->lchild,current);
}
void Bintree::output1()
{
    inoder();
    while(flag>0)
    {
        cout<<')';
        flag--;
    }
    cout<<"=";
}


void Bintree::inoder(Binnode *node)//中序
{
    if(node!=NULL)
    {
        inoder(node->lchild);
        if(flag==1&&node->lchild!=NULL&&node->rchild!=NULL)
        {
            Binnode *p=node;
            int flag2=0;
            while(p!=root)
            {
                p=parent(root,p);
                if(p->data=='*'||p->data=='/')
                {
                    flag2=1;
                    break;
                }
            }
            if(flag2==0)
            {
                cout<<')';
                flag--;
            }
        }
        cout<<node->data;
        if(node->data=='*'||node->data=='/')
        {


            if(node->lchild->data=='+'||node->lchild->data=='-'||node->rchild->data=='+'||node->rchild->data=='-')
            {
                cout<<'(';
                flag++;
            }
        }
        inoder(node->rchild);
    }
}


void Bintree::postoder(Binnode *node)//后序
{


    if(node!=NULL)
    {
        postoder(node->lchild);
        postoder(node->rchild);
        if(node->data!='+'&&node->data!='-'&&node->data!='*'&&node->data!='/')
        {
            s->push(node->data);
        }
        else
        {
            char b=s->pop();
            char a=s->pop();
            if(node->data=='+')
            {
                result=(a-'0')+(b-'0');
                s->push(a-'0'+b-'0'+'0');
            }
            else if(node->data=='-')
            {
                result=(a-'0')-(b-'0');
                s->push((a-'0')-(b-'0')+'0');
            }
            else if(node->data=='*')
            {
                result=(a-'0')*(b-'0');
                s->push((a-'0')*(b-'0')+'0');
            }
            else if(node->data=='/')
            {
                result=(a-'0')/(b-'0');
                s->push((a-'0')/(b-'0')+'0');
            }
        }
    }
}


int main()
{
    Bintree *tree=new Bintree();
    tree->createbintree();
    tree->output1();
    tree->postoder();
    tree->output2();
    cout<<endl;
    return 0;
}

将通过二叉链表实现的表达式二叉树进行输出，同时计算出结果。

要求：

1）二叉树建立时，使用先序建立；

2）四个运算符包括：+, -, *, /;

3 ) 在输出时，遇到优先级问题时，相应的括号也要输出。

提示：

1）递归执行下列步骤即可求值：先分别求出左子树和右子树表示的子表达式的值，最后根据根结点的运算符的要求，计算出表达式的最后结果。
 

2）二叉树的中序遍历序列与原算术表达式基本相同，但是需要将中序序列加上括号，即当根结点运算符优先级高于左子树（或右子树）根结点运算符时，就需要加括号。

 

输入：

-+3@@*2@@-4@@1@@/6@@2@@

输出：

3+2*(4-1)-6/2=6