给定表达式为：a*b+(c-d)/e 建立表达式二叉树

建立表达式二叉树。

给定表达式为：a*b+(c-d)/e

要求：首先调用中缀后缀转换程序，实现中缀表达式到后缀表达式的转换；然后针对后缀表达式边读表达式边建立二叉树。

　　　可正向打印二叉树，若有困难，可逆时针转动90度再打印。

=============================================

源代码

--------------------------------------------------

tnode.h

-------------------------------------------------

#include<iostream>

using namespace std;

 

#include <stack>

#include <iomanip>

 

template <typename T>

class tnode

{

   public:

T nodeValue;

tnode<T> *left, *right;

tnode(){}

tnode (const T& item, tnode<T> *lptr = NULL, tnode<T> *rptr = NULL):nodeValue(item), left(lptr), right(rptr){}

tnode<T>* buildTree(string exp);

int depth(tnode<T> *root);

void print(tnode<T> *node_ptr, int depth);

};

 

template <typename T>

tnode<T> *tnode<T>::buildTree(string exp)

{

int i=0;

stack<tnode<T>*> tex;

tnode<T> *a;

T b=exp[i++];

while(b!='\0')

{

if(b!='*' && b!='/' && b!='+' && b!='-' && b!='%'){

a=new tnode<T>(b);

tex.push(a);

b=exp[i++];

}else{

a=new tnode<T>(b);

if(!tex.empty()){

a->right=tex.top();

tex.pop();

}

if(!tex.empty()){

a->left=tex.top();

tex.pop();

}

tex.push(a);

b=exp[i++];

}

}

return a;

}

 

template <typename T>

int tnode<T>::depth(tnode<T> *root)

{

         int i=0,j=0;

         if(root==NULL)

 return -1;

         i=depth(root->left);

         j=depth(root->right);

         return i>j?i+1:j+1; 

}

 

template <typename T>

void tnode<T>::print(tnode<T> *node_ptr, int depth)//逆时针90度打印二叉树

{      

    if (node_ptr!= NULL)

    {

        print(node_ptr->right, depth+1);

        cout<<setw(4*depth)<<" ";

        cout<<node_ptr->nodeValue<<endl;

        print(node_ptr->left,depth+1);

    }

}

 

--------------------------------------------------

vstack.h

-------------------------------------------------

#include<vector>

#include<iostream>

using namespace std;

 

class vstack

{

public:

vstack();

int size() const;

bool empty() const;

void push(const int& item);

void pop();

int top() const;

void display();

private:

vector<char> v;

int Top;

};

 

vstack::vstack()

{

Top=0;

}

 

bool vstack::empty() const

{

if(Top==0){

return true;

}else{

return false;

}

}

 

void vstack::push(const int& item)

{

++Top;

v.push_back(item);

}

 

void vstack::pop()

{

if(v.size==0){

cerr<< "*** stack is empty -- can't remove a value ***\n";

exit(1);

}else{

--Top;

v.pop_back();

}

}

 

int vstack::top() const

{

if(v.size()==0){

cerr<< "*** stack is empty -- can't remove a value ***\n";

exit(1);

}else{

return v[Top-1];

}

}

int vstack::size() const

{

return v.size();

}

void vstack::display(){

if(v.size()==0){

cerr<< "*** stack is empty -- can't remove a value ***\n";

exit(1);

}else{

cout<<"all the stack: ";

for(int i=0;i<Top;i++){

cout<<v[i]<<" ";

}

cout<<endl;

}

}

 

 

--------------------------------------------------

tree.cpp

-------------------------------------------------

 

#include <iostream>

using namespace std;

#include "vstack.h"

#include "tnode.h"

#include <stack>

 

//中缀转后缀

#include <string>   //string,==,find,npos

#include <cassert>//?  assert()

#include <cctype>//?   alnum()

string postfix(string exp);

 

int main()

{

string infixExp;

cout<<"Please input the expression:"<<endl;

cout<<"NOTE: Enter # for infix expression to stop.\n";

for(;;){

//中缀转后缀

cout<<"\nInfix expression? ";

cin>>infixExp;

if(infixExp == "#") break;

string exp=postfix(infixExp);

cout<<"Postfix expression is "<<exp<<endl;

//后缀压栈

tnode<char> tree(' ');

tnode<char> *ptr=tree.buildTree(exp);

int d=tree.depth(ptr);

tree.print(ptr,2);

}

return 0;

}

 

//中缀转后缀

string postfix(string exp)

{

char token,        //exp中的字符

topToken;      //opStack栈顶的标记

vstack opstack;    //运算符栈

string postfixExp;    //后缀表达式

const string BLANK="";   //空白

for(int i=0;i<exp.length();i++){

token=exp[i];

switch(token)

{

case ' ': break;

case '(': opstack.push(token);

      break;

case ')': for(;;)

  {

  assert(!opstack.empty());

  topToken=opstack.top();

  opstack.pop();

  if(topToken == '(') break;

  postfixExp.append(BLANK + topToken);

  //return topToken;

  }

      break;

case '+': case '-':

case '*': case '/': case '%':

      for(;;)

  {

  if( (opstack.empty())

  || (opstack.top() == '(' )

  || (token == '*' || token == '/' || token == '%') 

  && (opstack.top() == '+' || opstack.top() == '-'))

  {

  opstack.push(token);

  break;

  }else{

  topToken = opstack.top();

  opstack.pop();

  postfixExp.append(BLANK + topToken);

  //return topToken;

  }

  }

  break;

default: postfixExp.append( BLANK + token);

     for(;;)

 {

 if ( !isalnum(exp[i+1]) ) break;  //标示符结尾

 i++;

 token = exp[i];

 postfixExp.append(1,token);

 //return topToken;

 }

}

}

for(;;)

{

if(opstack.empty() ) break;

topToken = opstack.top();

opstack.pop();

if( topToken != '(')

{

postfixExp.append(BLANK + topToken);

//return topToken;

}

else

{

cout<<" *** Error in infix expression *** \n";

break;

}

}

return postfixExp;

}