C++ programming. The program does not find the EmployeeId, please help me fix th
ID: 3818982 • Letter: C
Question
C++ programming. The program does not find the EmployeeId, please help me fix the error.
In this program you are going to use the binary tree class you created in Assignment 1 this week. First create a class called EmployeeInfo that holds two private data members. One data member is an integer called empID which holds the id number of the employee. The second data member is a string called empName which holds the full name of the employee. The program will create an instance of the binary tree class with a data type of EmployeeInfo (BinaryTree). The binary tree will be sorted by the Employee ID number found in the EmployeeInfo class. The program should then allow the user to search for Employee by the Employee ID. If the employee is found in the tree, its name and ID should be displayed. If not, a message should be displayed indicating that it was not found. Sample data would be
1021 John Williams
1057 Bill Witherspoon
2487 Jennifer Twain
3769 Sophia Lancaster
1017 Debbie Reece
1275 George McMullen
1899 Ashley Smith
4218 Josh Plemmons
//BinaryTree.h
#ifndef BINARYTREE_H
#define BINARYTREE_H
#include
using namespace std;
template
class BinaryTree
{
private:
struct TreeNode
{
T value; // The value in the node
TreeNode *left; // Pointer to left child node
TreeNode *right; // Pointer to right child node
};
TreeNode *root; // Pointer to the root node
// Private member functions
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:
// Constructor
BinaryTree()
{
root = NULL;
}
// Destructor
~BinaryTree()
{
destroySubTree(root);
}
// Binary tree operations
void insertNode(T);
bool searchNode(T);
void remove(T);
void displayPreOrder() const
{
displayPreOrder(root);
}
void displayInOrder() const
{
displayInOrder(root);
}
void displayPostOrder() const
{
displayPostOrder(root);
}
// Node counter
int counter()
{
int n = counter(root);
return n;
}
// Leaf counter
int leafCounter()
{
int leaf = leafCounter(root);
return leaf;
}
// Height of the tree
int height()
{
int h = height(root);
return h;
}
};
//*********************************************************
// insert function accepts a TreeNode pointer and a *
// pointer to a node. The function inserts the node into *
// the tree pointer to by the TreeNode pointer. This *
// function is call recursively. *
//*********************************************************
template
void BinaryTree::insert(TreeNode *&nodePtr, TreeNode *&newNode)
{
if (nodePtr == NULL)
nodePtr = newNode; // Insert the node
else if (newNode->value < nodePtr->value)
insert(nodePtr->left, newNode); // Search the left branch
else
insert(nodePtr->right, newNode);// Search the right branch
}
//*********************************************************
// insertNode creates anew node to hold num as its value *
// and passes it to the insert function. *
//*********************************************************
template
void BinaryTree::insertNode(T item)
{
TreeNode *newNode; // Pointer to a new node
// Create anew node and store num in it
newNode = new TreeNode;
newNode->value = item;
newNode->left = newNode->right = NULL;
// Insert the node
insert(root, newNode);
}
//**********************************************************
// destroySubTree is called by the destructor. It deletes *
// all nodes in the tree. *
//**********************************************************
template
void BinaryTree::destroySubTree(TreeNode *nodePtr)
{
if (nodePtr)
{
if (nodePtr->left)
destroySubTree(nodePtr->left);
if (nodePtr->right)
destroySubTree(nodePtr->right);
delete nodePtr;
}
}
//**********************************************************
// searchNode determines if a value is present in the tree.*
// If so, the function returns true. Otherwise it returns *
// false.
//**********************************************************
template
bool BinaryTree::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;
}
//*********************************************************
// remove calls deleteNode to delete the node whode value *
// member is the same as num *
//*********************************************************
template
void BinaryTree::remove(T item)
{
deleteNode(item, root);
}
//*********************************************************
// deleteNode deletes the node whose value member is the *
// same as num *
//*********************************************************
template
void BinaryTree::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);
}
//*********************************************************
// makeDeletion takes a reference to apointer to the node *
// that is to be deleted. The node is removed and the *
// branches of the tree below the node are reattached *
//*********************************************************
template
void BinaryTree::makeDeletion(TreeNode *&nodePtr)
{
// Define a temporary pointer to use in reattaching
// the left subtree
TreeNode *tempNodePtr;
if (nodePtr == NULL)
cout << "Cannot delete empty node. ";
else if (nodePtr->right == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->left; // Reattach the left child
delete tempNodePtr;
}
else if (nodePtr->left == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->right; // Reattach the right child
delete tempNodePtr;
}
}
//*********************************************************
// The displayInOrder function displays the values in the *
// subtree pointed to by nodePtr, via inorder traversal *
//*********************************************************
template
void BinaryTree::displayInOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
displayInOrder(nodePtr->left);
cout << nodePtr->value.getEmpID() << " "
<< nodePtr->value.getEmpName() << endl;
displayInOrder(nodePtr->right);
}
}
//*********************************************************
// The displayPreOrder function displays the values in the*
// subtree pointed to by nodePtr, via Preorder traversal *
//*********************************************************
template
void BinaryTree::displayPreOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
cout << nodePtr->value << endl;
displayInOrder(nodePtr->left);
displayInOrder(nodePtr->right);
}
}
//*********************************************************
// displayPostOrder function displays the values in the *
// subtree pointed to by nodePtr, via Postorder traversal *
//*********************************************************
template
void BinaryTree::displayPostOrder(TreeNode *nodePtr) const
{
if (nodePtr)
{
displayInOrder(nodePtr->left);
displayInOrder(nodePtr->right);
cout << nodePtr->value << endl;
}
}
#endif
//EmployeeInfo.h
#pragma once
#ifndef EMPLOYEEINFO_H
#define EMPLOYEEINFO_H
#include "BinaryTree.h"
#include
#include
using namespace std;
class EmployeeInfo
{
friend class BinaryTree;
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
//Main.cpp
#include "EmployeeInfo.h"
#include "BinaryTree.h"
#include
#include
#include
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");
BinaryTree 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;
char again = 'y';
int id;
cout << "would you like to search for an employee? (Y/N): ";
cin >> again;
if (again)
{
do
{
cout << "enter the ID number: ";
cin >> id;
EmployeeInfo info;
info.getEmpID();
if (tree.searchNode(info))
{
cout << info.getEmpID() << endl;
}
else
cout << "Not found" << endl;
cout << "Would you like to continue? (Y/N): ";
cin >> again;
} while (again == tolower('Y'));
}
system("pause");
return 0;
}
Explanation / Answer
if (again)
{
do
{
cout << "enter the ID number: ";
cin >> id;
EmployeeInfo info;
int ID_ID = info.getEmpID();
if (tree.searchNode(info))
{
cout << ID_ID << endl;
}
else
cout << "Not found" << endl;
cout << "Would you like to continue? (Y/N): ";
cin >> again;
} while (again == tolower('Y'));
}
system("pause");
return 0;
}
Hope It works.Good Luck!
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.