Please add comments to this C++ program :) // File: EmployeeInfo.h #ifndef EMPLO

ID: 3771645 • Letter: P

Question

Please add comments to this C++ program :)

// File: EmployeeInfo.h
#ifndef EMPLOYEEINFO_H
#define EMPLOYEEINFO_H

#include "BinaryTree.h"
#include <iostream>
#include <string>
using namespace std;

class EmployeeInfo
{
friend class BinaryTree<EmployeeInfo>;
friend ostream &operator<<(ostream &out, const EmployeeInfo &obj);

private:
int empID;
string empName;

public:

   EmployeeInfo();
   EmployeeInfo(int id, string name);
   int getEmpID();
   string getEmpName();
   bool operator==(int value);
   bool operator==(const EmployeeInfo& emp);
   bool operator<(const EmployeeInfo& emp);
   bool operator>(const EmployeeInfo& emp);
};

EmployeeInfo::EmployeeInfo()
{
empID = 0;
empName = "";
}

EmployeeInfo::EmployeeInfo(int id, string name)
{
empID = id;
empName = name;
}

int EmployeeInfo::getEmpID()
{
return empID;
}

string EmployeeInfo::getEmpName()
{
return empName;
}

bool EmployeeInfo::operator==(int value)
{
return this->getEmpID() == value;
}

bool EmployeeInfo::operator==(const EmployeeInfo& emp)
{
return this->empID == emp.empID;
}

bool EmployeeInfo::operator<(const EmployeeInfo& emp)
{
return this->empID < emp.empID;
}

bool EmployeeInfo::operator>(const EmployeeInfo& emp)
{
return this->empID > emp.empID;
}

ostream &operator<<(ostream &out, const EmployeeInfo &obj)
{
out << "EmpID: " << obj.empID << ", EmpName: " << obj.empName << endl;
return out;
}

#endif

// File: BinaryTree.h
#ifndef BINARYTREE_H
#define BINARYTREE_H

#include "EmployeeInfo.h"
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;

template <class T>
class BinaryTree
{
private:

struct TreeNode
{
T value;
TreeNode *left;
TreeNode *right;
};

TreeNode *root;
void insert(TreeNode *&, TreeNode *&);
void destroySubTree(TreeNode *);
void deleteNode(T, TreeNode *&);
void makeDeletion(TreeNode *&);
void displayInOrder(TreeNode *) const;
void displayPreOrder(TreeNode *) const;
void displayPostOrder(TreeNode *) const;

public:
BinaryTree()
{
root = NULL;
}
~BinaryTree()
{
destroySubTree(root);
}
void insertNode(T);
void remove(T);
bool searchNode(T item);

void displayPreOrder() const
{
displayPreOrder(root);
}
void displayInOrder() const
{
displayInOrder(root);
}
void displayPostOrder() const
{
displayPostOrder(root);
}
};
template <class T>
void BinaryTree<T>::insert(TreeNode *&nodePtr, TreeNode *&newNode)
{
if (nodePtr == NULL)
nodePtr = newNode;
else if (newNode->value < nodePtr->value)
insert(nodePtr->left, newNode);
else
insert(nodePtr->right, newNode);
}
template <class T>
void BinaryTree<T>::insertNode(T item)
{
TreeNode *newNode;
newNode = new TreeNode;
newNode->value = item;
newNode->left = newNode->right = NULL;
insert(root, newNode);
}
template <class T>
void BinaryTree<T>::destroySubTree(TreeNode *nodePtr)
{
if (nodePtr)
{
if (nodePtr->left)
destroySubTree(nodePtr->left);
if (nodePtr->right)
destroySubTree(nodePtr->right);
delete nodePtr;
}
}

template <class T>
bool BinaryTree<T>::searchNode(T item)
{
TreeNode *nodePtr = root;

while (nodePtr)
{
if (nodePtr->value == item)
return true;
else if (item < nodePtr->value)
nodePtr = nodePtr->left;
else
nodePtr = nodePtr->right;
}
return false;
}

template <class T>
void BinaryTree<T>::remove(T item)
{
deleteNode(item, root);
}
template <class T>
void BinaryTree<T>::deleteNode(T item, TreeNode *&nodePtr)
{
if (item < nodePtr->value)
deleteNode(item, nodePtr->left);
else if (item > nodePtr->value)
deleteNode(item, nodePtr->right);
else
makeDeletion(nodePtr);
}
template <class T>
void BinaryTree<T>::makeDeletion(TreeNode *&nodePtr)
{
TreeNode *tempNodePtr;
if (nodePtr == NULL)
cout << "Cannot delete empty node. ";
else if (nodePtr->right == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->left;
delete tempNodePtr;
}
else if (nodePtr->left == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->right;
delete tempNodePtr;
}
}
template <class T>
void BinaryTree<T>::displayInOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
displayInOrder(nodePtr->left);
cout << nodePtr->value;
displayInOrder(nodePtr->right);
}
}
template <class T>
void BinaryTree<T>::displayPreOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
cout << nodePtr->value;
displayInOrder(nodePtr->left);
displayInOrder(nodePtr->right);
}
}
template <class T>
void BinaryTree<T>::displayPostOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
displayInOrder(nodePtr->left);
displayInOrder(nodePtr->right);
cout << nodePtr->value;
}
}
#endif

// File: BinaryTreeTest.cpp
#include "EmployeeInfo.h"
#include "BinaryTree.h"
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;

int main()
{
   EmployeeInfo emp1(1021, "John Williams");
   EmployeeInfo emp2(1057, "Bill Witherspoon");
   EmployeeInfo emp3(2487, "Jennifer Twain");
   EmployeeInfo emp4(3769, "Sophia Lancaster");
   EmployeeInfo emp5(1017, "Debbie Reece");
   EmployeeInfo emp6(1275, "George McMullen");
   EmployeeInfo emp7(1899, "Ashley Smith");
   EmployeeInfo emp8(4218, "Josh Plemmons");
   EmployeeInfo emp9(2589, "Mike Bmoom");

   BinaryTree<EmployeeInfo> tree;
   tree.insertNode(emp1);
   tree.insertNode(emp2);
   tree.insertNode(emp3);
   tree.insertNode(emp4);
   tree.insertNode(emp5);
   tree.insertNode(emp6);
   tree.insertNode(emp7);
   tree.insertNode(emp8);

tree.displayInOrder();
cout << endl;

   if(tree.searchNode(emp4))
       cout << "Found: " << emp4;
   else
       cout << "Not Found: " << emp4;

   if(tree.searchNode(emp9))
           cout << "Found: " << emp9;
       else
           cout << "Not Found: " << emp9;

return 0;
}

Explanation / Answer

// File: EmployeeInfo.h
#ifndef EMPLOYEEINFO_H
#define EMPLOYEEINFO_H

#include "BinaryTree.h"
#include <iostream>
#include <string>
using namespace std;

class EmployeeInfo /* creat a class named employee */
{/* variables are */
friend class BinaryTree<EmployeeInfo>;
friend ostream &operator<<(ostream &out, const EmployeeInfo &obj);

private:
int empID;
string empName;

public:

   EmployeeInfo(); /*default constructor */
   EmployeeInfo(int id, string name); /* parameterised constructor */
   int getEmpID();        /* public member functions */
   string getEmpName(); /* function to take the name */
   bool operator==(int value);
   bool operator==(const EmployeeInfo& emp);
   bool operator<(const EmployeeInfo& emp);
   bool operator>(const EmployeeInfo& emp);
};

EmployeeInfo::EmployeeInfo() /* defination of default constructor */
{
empID = 0;
empName = "";
}

EmployeeInfo::EmployeeInfo(int id, string name) /*defination of parameterised constructor */
{
empID = id;
empName = name;
}

int EmployeeInfo::getEmpID() /* function to get the employee id */
{
return empID;
}

string EmployeeInfo::getEmpName() /* function to get the name */
{
return empName;
}

bool EmployeeInfo::operator==(int value)
{
return this->getEmpID() == value;
}

bool EmployeeInfo::operator==(const EmployeeInfo& emp)
{
return this->empID == emp.empID;
}

bool EmployeeInfo::operator<(const EmployeeInfo& emp)
{
return this->empID < emp.empID;
}

bool EmployeeInfo::operator>(const EmployeeInfo& emp)
{
return this->empID > emp.empID;
}

ostream &operator<<(ostream &out, const EmployeeInfo &obj) /* displays employee id,name */
{
out << "EmpID: " << obj.empID << ", EmpName: " << obj.empName << endl;
return out;
}

#endif

// File: BinaryTree.h
#ifndef BINARYTREE_H
#define BINARYTREE_H

#include "EmployeeInfo.h"
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;

template <class T>
class BinaryTree
{
private:

struct TreeNode
{
T value;
TreeNode *left;
TreeNode *right;
};

public:
BinaryTree() /* constructor defination */
{
root = NULL;
}
~BinaryTree() /* destructor defination to destroy the tree */
{
destroySubTree(root);
}
void insertNode(T); /* function to instert a node in a tree */
void remove(T);
bool searchNode(T item);

void displayPreOrder() const /* display tree with preorder traversal */
{
displayPreOrder(root);
}
void displayInOrder() const /* display tree with inorder traversal */
{
displayInOrder(root);
}
void displayPostOrder() const /* display tree with postorder traversal */
{
displayPostOrder(root);
}
};
template <class T>
void BinaryTree<T>::insert(TreeNode *&nodePtr, TreeNode *&newNode) /* to insert a node in a tree */
{
if (nodePtr == NULL)
nodePtr = newNode;
else if (newNode->value < nodePtr->value)
insert(nodePtr->left, newNode);
else
insert(nodePtr->right, newNode);
}
template <class T>
void BinaryTree<T>::insertNode(T item)
{
TreeNode *newNode;
newNode = new TreeNode;
newNode->value = item;
newNode->left = newNode->right = NULL;
insert(root, newNode);
}
template <class T>
void BinaryTree<T>::destroySubTree(TreeNode *nodePtr) /* to delete a tree by deleting it nodes */
{
if (nodePtr)
{
if (nodePtr->left)
destroySubTree(nodePtr->left);
if (nodePtr->right)
destroySubTree(nodePtr->right);
delete nodePtr;
}
}

template <class T>
bool BinaryTree<T>::searchNode(T item) /* to search a given node in a tree */
{
TreeNode *nodePtr = root;

while (nodePtr)
{
if (nodePtr->value == item)
return true;
else if (item < nodePtr->value)
nodePtr = nodePtr->left;
else
nodePtr = nodePtr->right;
}
return false;
}

template <class T>
void BinaryTree<T>::remove(T item) /* remove each node so that the whole tree gets destroyed */
{
deleteNode(item, root);
}
template <class T>
void BinaryTree<T>::deleteNode(T item, TreeNode *&nodePtr) /* deleting of subtree and whole tree nodes */
{
if (item < nodePtr->value)
deleteNode(item, nodePtr->left);
else if (item > nodePtr->value)
deleteNode(item, nodePtr->right);
else
makeDeletion(nodePtr);
}
template <class T>
void BinaryTree<T>::makeDeletion(TreeNode *&nodePtr) /* perform deletion */
{
TreeNode *tempNodePtr;
if (nodePtr == NULL)
cout << "Cannot delete empty node. ";
else if (nodePtr->right == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->left;
delete tempNodePtr;
}
else if (nodePtr->left == NULL) /* deleting the branches of tree and then the tree nodes */
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->right;
delete tempNodePtr;
}
}
template <class T>
void BinaryTree<T>::displayInOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
displayInOrder(nodePtr->left);
cout << nodePtr->value;
displayInOrder(nodePtr->right);
}
}
template <class T>
void BinaryTree<T>::displayPreOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
cout << nodePtr->value;
displayInOrder(nodePtr->left);
displayInOrder(nodePtr->right);
}
}
template <class T>
void BinaryTree<T>::displayPostOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
displayInOrder(nodePtr->left);
displayInOrder(nodePtr->right);
cout << nodePtr->value;
}
}
#endif

// File: BinaryTreeTest.cpp
#include "EmployeeInfo.h"
#include "BinaryTree.h"
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;

tree.displayInOrder();
cout << endl;

   if(tree.searchNode(emp4))
       cout << "Found: " << emp4;
   else
       cout << "Not Found: " << emp4;

   if(tree.searchNode(emp9))
           cout << "Found: " << emp9;
       else
           cout << "Not Found: " << emp9;

return 0;
}

Navigate

Please add comments to the code so i can understand it, thanks Design and implem

Please add comments to this code import java.io.*; import java.util.*; import ja

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

Please add comments to this C++ program :) // File: EmployeeInfo.h #ifndef EMPLO

Question

Explanation / Answer

Related Questions

Navigate