C++ (ADT). please implement the ExpressionTree.cpp file and attach screenshot of the output .

 ExpressionTree.h 

//-------------------------------------------------------------------- // // Laboratory 8 ExpressionTree.h // // Class declarations for the linked implementation of the // Expression Tree ADT -- including the recursive helpers for the // public member functions // // Instructor copy with the recursive helper function declarations. // The student version does not have those, but has a place to write // the declarations in the private section. // //-------------------------------------------------------------------- #ifndef EXPRESSIONTREE_H #define EXPRESSIONTREE_H #include  #include  using namespace std; template  class ExprTree { public: // Constructor ExprTree (); ExprTree(const ExprTree& source); ExprTree& operator=(const ExprTree& source); // Destructor ~ExprTree (); // Expression tree manipulation operations void build (); void expression () const; DataType evaluate() const throw (logic_error); void clear (); // Clear tree void commute(); bool isEquivalent(const ExprTree& source) const; bool isEmpty() const; // Output the tree structure -- used in testing/debugging void showStructure () const; private: class ExprTreeNode { public: // Constructor ExprTreeNode ( char elem, ExprTreeNode *leftPtr, ExprTreeNode *rightPtr ); // Data members char dataItem; // Expression tree data item ExprTreeNode *left, // Pointer to the left child *right; // Pointer to the right child }; // Recursive helper functions for the public member functions -- insert // prototypes of these functions here. void buildHelper(ExprTreeNode*& p); void exprHelper(ExprTreeNode* p) const; DataType evalHelper(ExprTreeNode* p) const; void clearHelper ( ExprTreeNode *p ); void showHelper ( ExprTreeNode *p, int level ) const; void copyHelper ( ExprTreeNode *&p ); void commuteHelper(ExprTreeNode* p); bool isEquivalentHelper(const ExprTreeNode* p, const ExprTreeNode* q) const; // Data member ExprTreeNode *root; // Pointer to the root node }; #endif // #ifndef EXPRESSIONTREE_H 

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

ExpressionTree.cpp 

#include "ExpressionTree.h" template  ExprTree::ExprTreeNode::ExprTreeNode ( char elem, ExprTreeNode *leftPtr, ExprTreeNode *rightPtr ) { } template  ExprTree::ExprTree () { } template  ExprTree::ExprTree(const ExprTree& source) { } template  ExprTree& ExprTree::operator=(const ExprTree& source) { } template  void ExprTree::copyHelper(ExprTreeNode *&p) {} template  ExprTree::~ExprTree () { } template  void ExprTree::build () { } template  void ExprTree::buildHelper(ExprTreeNode*& p) {} template  void ExprTree::buildHelper(ExprTreeNode*& p) {} template  void ExprTree::expression () const { } template  void ExprTree::exprHelper(ExprTreeNode* p) const {} template  DataType ExprTree::evaluate() const throw (logic_error) { DataType temp; return temp; } template  float ExprTree::evalHelper(ExprTreeNode* p) const { float temp; return temp; } template  bool ExprTree::evalHelper(ExprTreeNode* p) const { bool temp; return temp; } template  void ExprTree::clear () { } template  void ExprTree::clearHelper(ExprTreeNode *p) {} template  void ExprTree::commute() { } template  void ExprTree::commuteHelper(ExprTreeNode* p) {} template  bool ExprTree::isEquivalent(const ExprTree& source) const { } template  bool ExprTree::isEquivalentHelper(const ExprTreeNode* x, const ExprTreeNode* y) const {} template  bool ExprTree::isEmpty() const { return false; } template  void ExprTree::showStructure() const // Outputs an expression tree. The tree is output rotated counter- // clockwise 90 degrees from its conventional orientation using a // "reverse" inorder traversal. This operation is intended for testing // and debugging purposes only. { // No isEmpty function in this class. Add a private one if you wish. if (root == 0) cout  void ExprTree::showHelper(ExprTreeNode *p, int level) const // Recursive helper for the showStructure() function. Outputs the // subtree whose root node is pointed to by p. Parameter level is the // level of this node within the expression tree. { int j; // Loop counter if (p != 0) { showHelper(p->right, level + 1); // Output right subtree for (j = 0; j dataItem; // Output dataItem if ((p->left != 0) && // Output "connector" (p->right != 0)) cout right != 0) cout left != 0) cout left, level + 1); // Output left subtree } } 

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

config.cpp

/** * Expression Tree class (Lab 8) configuration file. * Activate test #N by defining the corresponding LAB8_TESTN to have the value 1. */ #define LAB8_TEST1 0 // Programming Exercise 1: Logic tree activator #define LAB8_TEST2 0 // Programming Exercise 2: Commute operation #define LAB8_TEST3 0 // Programming Exercise 3: isEquivalent operation 

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

test8.cpp

//-------------------------------------------------------------------- // // Laboratory 8 test8.cpp // // Test program for the operations in the Expression Tree ADT // //-------------------------------------------------------------------- #include  #include  using namespace std; //#include "ExprTree.cpp" #include "ExpressionTree.cpp" #include "config.h" //-------------------------------------------------------------------- // Function prototype template  void dummy ( ExprTree copyTree ); // copyTree is passed by value //-------------------------------------------------------------------- int main() { #if !LAB8_TEST1 || LAB8_TEST2 || LAB8_TEST3 // Don't do this if testing boolean tree, unless also testing programming // exercises 2 or 3 (for which this section is mostly needed). // The tricky part occurs if testing exercise 1 and (2 or 3), or if // someone is trying to test the basic class and one of the other exercises // in parallel. Hence the #if expression above. cout  testExpression; // Test expression cout  boolTree; cout  same = testExpression; cout  empty; cout  userExpression; cout  void dummy ( ExprTree copyTree ) // Dummy routine that is passed an expression tree using call by // value. Outputs copyTree and clears it. { cout   Questions Implement a tree which constructs an expression tree from the prefix form of an arithmetic expression. Example of the prefix form: *+ 13-64 Example of the infix form: (1 + 3) * (6-4) Functions to implement: build builds corresponding expression tree: (25 pts) expression0- converts and outputs prefix form into infix form: (25 pts) evaluate) - returns the value of corresponding expression tree: (25 pts) - Other functions (constructor, copy constructor, desctructor, clear) (25 pts)  Questions Implement a tree which constructs an expression tree from the prefix form of an arithmetic expression. Example of the prefix form: *+ 13-64 Example of the infix form: (1 + 3) * (6-4) Functions to implement: build builds corresponding expression tree: (25 pts) expression0- converts and outputs prefix form into infix form: (25 pts) evaluate) - returns the value of corresponding expression tree: (25 pts) - Other functions (constructor, copy constructor, desctructor, clear) (25 pts)