A binary tree is a complete binary tree if all the internal nodes (including the root...
A binary tree is a complete binary tree if all the internal nodes (including the root node) have exactly two child nodes and all the leaf nodes are at level 'h' corresponding to the height of the tree.
Consider the code for the binary tree given to you for this question. Add code in the blank space provided for the member function checkCompleteBinaryTree( ) in the BinaryTree class. This member function should check whether the binary tree input by the user (in the form of the edge information stored in a file) is a complete binary tree.
To test your code, come up with two binary trees of at least 12 vertices: one, a complete binary tree and another, a binary tree that is not a complete tree.
Prepare the input file for the two binary trees and input them to the code for this question. Capture the screenshots of the outputs.
Give the entire code (including the implementation of the function to check whether a binary tree is complete)
Code Given:
#include <iostream>
#include <fstream>
#include <string>
#include <cstring> // for string tokenizer and c-style string processing
#include <algorithm> // max function
using namespace std;
class BTNode{
private:
int nodeid;
int data;
int levelNum;
BTNode* leftChildPtr;
BTNode* rightChildPtr;
public:
BTNode(){}
void setNodeId(int id){
nodeid = id;
}
int getNodeId(){
return nodeid;
}
void setData(int d){
data = d;
}
int getData(){
return data;
}
void setLevelNum(int level){
levelNum = level;
}
int getLevelNum(){
return levelNum;
}
void setLeftChildPtr(BTNode* ptr){
leftChildPtr = ptr;
}
void setRightChildPtr(BTNode* ptr){
rightChildPtr = ptr;
}
BTNode* getLeftChildPtr(){
return leftChildPtr;
}
BTNode* getRightChildPtr(){
return rightChildPtr;
}
int getLeftChildID(){
if (leftChildPtr == 0)
return -1;
return leftChildPtr->getNodeId();
}
int getRightChildID(){
if (rightChildPtr == 0)
return -1;
return rightChildPtr->getNodeId();
}
};
class Node{
private:
int data;
Node* nextNodePtr;
Node* prevNodePtr;
public:
Node(){}
void setData(int d){
data = d;
}
int getData(){
return data;
}
void setNextNodePtr(Node* nodePtr){
nextNodePtr = nodePtr;
}
Node* getNextNodePtr(){
return nextNodePtr;
}
void setPrevNodePtr(Node* nodePtr){
prevNodePtr = nodePtr;
}
Node* getPrevNodePtr(){
return prevNodePtr;
}
};
class Queue{
private:
Node* headPtr;
Node* tailPtr;
public:
Queue(){
headPtr = new Node();
tailPtr = new Node();
headPtr->setNextNodePtr(0);
tailPtr->setPrevNodePtr(0);
}
Node* getHeadPtr(){
return headPtr;
}
Node* getTailPtr(){
return tailPtr;
}
bool isEmpty(){
if (headPtr->getNextNodePtr() == 0)
return true;
return false;
}
void enqueue(int data){
Node* newNodePtr = new Node();
newNodePtr->setData(data);
newNodePtr->setNextNodePtr(0);
Node* lastNodePtr = tailPtr->getPrevNodePtr();
if (lastNodePtr == 0){
headPtr->setNextNodePtr(newNodePtr);
newNodePtr->setPrevNodePtr(0);
}
else{
lastNodePtr->setNextNodePtr(newNodePtr);
newNodePtr->setPrevNodePtr(lastNodePtr);
}
tailPtr->setPrevNodePtr(newNodePtr);
}
int dequeue(){
Node* firstNodePtr = headPtr->getNextNodePtr();
Node* nextNodePtr = 0;
int poppedData = -100000; //empty queue
if (firstNodePtr != 0){
nextNodePtr = firstNodePtr->getNextNodePtr();
poppedData = firstNodePtr->getData();
}
else
return poppedData;
if (nextNodePtr != 0){
nextNodePtr->setPrevNodePtr(0);
headPtr->setNextNodePtr(nextNodePtr);
}
else{
headPtr->setNextNodePtr(0);
tailPtr->setPrevNodePtr(0);
}
return poppedData;
}
int peek(){
Node* firstNodePtr = headPtr->getNextNodePtr();
if (firstNodePtr != 0)
return firstNodePtr->getData();
else
return -100000; //empty queue
}
};
class BinaryTree{
private:
int numNodes;
BTNode* arrayOfBTNodes;
public:
BinaryTree(int n){
numNodes = n;
arrayOfBTNodes = new BTNode[numNodes];
for (int id = 0; id < numNodes; id++){
arrayOfBTNodes[id].setNodeId(id);
arrayOfBTNodes[id].setLevelNum(-1);
arrayOfBTNodes[id].setLeftChildPtr(0);
arrayOfBTNodes[id].setRightChildPtr(0);
}
}
void setLeftLink(int upstreamNodeID, int downstreamNodeID){
arrayOfBTNodes[upstreamNodeID].setLeftChildPtr(&arrayOfBTNodes[downstreamNodeID]);
}
void setRightLink(int upstreamNodeID, int downstreamNodeID){
arrayOfBTNodes[upstreamNodeID].setRightChildPtr(&arrayOfBTNodes[downstreamNodeID]);
}
void printLeafNodes(){
for (int id = 0; id < numNodes; id++){
if (arrayOfBTNodes[id].getLeftChildPtr() == 0 && arrayOfBTNodes[id].getRightChildPtr() == 0)
cout << id << " ";
}
cout << endl;
}
bool isLeafNode(int nodeid){
if (arrayOfBTNodes[nodeid].getLeftChildPtr() == 0 && arrayOfBTNodes[nodeid].getRightChildPtr() == 0)
return true;
return false;
}
int getNodeHeight(int nodeid){
if (nodeid == -1 || isLeafNode(nodeid) )
return 0;
int leftChildID = arrayOfBTNodes[nodeid].getLeftChildID(); // -1 if not exist
int rightChildID = arrayOfBTNodes[nodeid].getRightChildID(); // -1 if not exist
return max(getNodeHeight(leftChildID), getNodeHeight(rightChildID)) + 1;
}
int getTreeHeight(){
return getNodeHeight(0);
}
void assignLevelNumbers(){
Queue queue;
queue.enqueue(0);
arrayOfBTNodes[0].setLevelNum(0);
while (!queue.isEmpty()){
int firstNodeInQueue = queue.dequeue();
int leftChildID = arrayOfBTNodes[firstNodeInQueue].getLeftChildID();
if (leftChildID != -1){
queue.enqueue(leftChildID);
arrayOfBTNodes[leftChildID].setLevelNum(arrayOfBTNodes[firstNodeInQueue].getLevelNum()+1);
}
int rightChildID = arrayOfBTNodes[firstNodeInQueue].getRightChildID();
if (rightChildID != -1){
queue.enqueue(rightChildID);
arrayOfBTNodes[rightChildID].setLevelNum(arrayOfBTNodes[firstNodeInQueue].getLevelNum()+1);
}
}
}
int getDepth(int nodeid){
return arrayOfBTNodes[nodeid].getLevelNum();
}
bool checkCompleteBinaryTree(){
// Need to do three things
// (1) Get the height of the tree
// (2) Assign the level numbers for each node
// (3) If a node is not a leaf node (i.e., an internal node), check if its has two child nodes
// If a node is a leaf node, check if its level number equals the height of the tree
}
};
int main(){
string filename;
cout << "Enter a file name: ";
cin >> filename;
int numNodes;
cout << "Enter number of nodes: ";
cin >> numNodes;
BinaryTree binaryTree(numNodes);
ifstream fileReader(filename);
if (!fileReader){
cout << "File cannot be opened!! ";
return 0;
}
int numCharsPerLine = 10;
char *line = new char[numCharsPerLine];
// '10' is the maximum number of characters per line
fileReader.getline(line, numCharsPerLine, '\n');
// '\n' is the delimiting character to stop reading the line
while (fileReader){
char* cptr = strtok(line, ",: ");
string upstreamNodeToken(cptr);
int upstreamNodeID = stoi(upstreamNodeToken);
cptr = strtok(NULL, ",: ");
int childIndex = 0; // 0 for left child; 1 for right child
while (cptr != 0){
string downstreamNodeToken(cptr);
int downstreamNodeID = stoi(downstreamNodeToken);
if (childIndex == 0 && downstreamNodeID != -1)
binaryTree.setLeftLink(upstreamNodeID, downstreamNodeID);
if (childIndex == 1 && downstreamNodeID != -1)
binaryTree.setRightLink(upstreamNodeID, downstreamNodeID);
cptr = strtok(NULL, ",: ");
childIndex++;
}
fileReader.getline(line, numCharsPerLine, '\n');
}
if (binaryTree.checkCompleteBinaryTree())
cout << "The binary tree is a complete binary tree " << endl;
else
cout << "The binary tree is not a complete binary tree " << endl;
system("pause");
return 0;
}
Homework Answers
Please find the program below, copy and paste the program in any C++ IDE:
Step 1. compose the file which has contents in the format below:
0,1,2
1,3,4
2,5,6
3,7,8
4,9,10
5,11,12
6,13,14
Step 2. Run the program and provide:
1. the filename as input when prompt
2. the number of nodes, the example here has 15 nodes so provide 15
See the output, this example is a complete Binary Tree, you can change the file content to get an incomplete Binary Tree.
Program starts here:
#include <iostream>
#include <fstream>
#include <string>
#include <cstring> // for string tokenizer and c-style string processing
#include <algorithm> // max function
using namespace std;
class BTNode {
private:
int nodeid;
int data;
int levelNum;
BTNode *leftChildPtr;
BTNode *rightChildPtr;
public:
BTNode() {
}
void setNodeId(int id) {
nodeid = id;
}
int getNodeId() {
return nodeid;
}
void setData(int d) {
data = d;
}
int getData() {
return data;
}
void setLevelNum(int level) {
levelNum = level;
}
int getLevelNum() {
return levelNum;
}
void setLeftChildPtr(BTNode *ptr) {
leftChildPtr = ptr;
}
void setRightChildPtr(BTNode *ptr) {
rightChildPtr = ptr;
}
BTNode* getLeftChildPtr() {
return leftChildPtr;
}
BTNode* getRightChildPtr() {
return rightChildPtr;
}
int getLeftChildID() {
if (leftChildPtr == 0)
return -1;
return leftChildPtr->getNodeId();
}
int getRightChildID() {
if (rightChildPtr == 0)
return -1;
return rightChildPtr->getNodeId();
}
};
class Node {
private:
int data;
Node *nextNodePtr;
Node *prevNodePtr;
public:
Node() {
}
void setData(int d) {
data = d;
}
int getData() {
return data;
}
void setNextNodePtr(Node *nodePtr) {
nextNodePtr = nodePtr;
}
Node* getNextNodePtr() {
return nextNodePtr;
}
void setPrevNodePtr(Node *nodePtr) {
prevNodePtr = nodePtr;
}
Node* getPrevNodePtr() {
return prevNodePtr;
}
};
class Queue {
private:
Node *headPtr;
Node *tailPtr;
public:
Queue() {
headPtr = new Node();
tailPtr = new Node();
headPtr->setNextNodePtr(0);
tailPtr->setPrevNodePtr(0);
}
Node* getHeadPtr() {
return headPtr;
}
Node* getTailPtr() {
return tailPtr;
}
bool isEmpty() {
if (headPtr->getNextNodePtr() == 0)
return true;
return false;
}
void enqueue(int data) {
Node *newNodePtr = new Node();
newNodePtr->setData(data);
newNodePtr->setNextNodePtr(0);
Node *lastNodePtr = tailPtr->getPrevNodePtr();
if (lastNodePtr == 0) {
headPtr->setNextNodePtr(newNodePtr);
newNodePtr->setPrevNodePtr(0);
}
else {
lastNodePtr->setNextNodePtr(newNodePtr);
newNodePtr->setPrevNodePtr(lastNodePtr);
}
tailPtr->setPrevNodePtr(newNodePtr);
}
int dequeue() {
Node *firstNodePtr = headPtr->getNextNodePtr();
Node *nextNodePtr = 0;
int poppedData = -100000; //empty queue
if (firstNodePtr != 0) {
nextNodePtr = firstNodePtr->getNextNodePtr();
poppedData = firstNodePtr->getData();
}
else
return poppedData;
if (nextNodePtr != 0) {
nextNodePtr->setPrevNodePtr(0);
headPtr->setNextNodePtr(nextNodePtr);
}
else {
headPtr->setNextNodePtr(0);
tailPtr->setPrevNodePtr(0);
}
return poppedData;
}
int peek() {
Node *firstNodePtr = headPtr->getNextNodePtr();
if (firstNodePtr != 0)
return firstNodePtr->getData();
else
return -100000; //empty queue
}
};
class BinaryTree {
private:
int numNodes;
BTNode *arrayOfBTNodes;
public:
BinaryTree(int n) {
numNodes = n;
arrayOfBTNodes = new BTNode[numNodes];
for (int id = 0; id < numNodes; id++) {
arrayOfBTNodes[id].setNodeId(id);
arrayOfBTNodes[id].setLevelNum(-1);
arrayOfBTNodes[id].setLeftChildPtr(0);
arrayOfBTNodes[id].setRightChildPtr(0);
}
}
void setLeftLink(int upstreamNodeID, int downstreamNodeID) {
arrayOfBTNodes[upstreamNodeID].setLeftChildPtr(
&arrayOfBTNodes[downstreamNodeID]);
}
void setRightLink(int upstreamNodeID, int downstreamNodeID) {
arrayOfBTNodes[upstreamNodeID].setRightChildPtr(
&arrayOfBTNodes[downstreamNodeID]);
}
void printLeafNodes() {
for (int id = 0; id < numNodes; id++) {
if
(arrayOfBTNodes[id].getLeftChildPtr() == 0
&&
arrayOfBTNodes[id].getRightChildPtr() == 0)
cout << id << " ";
}
cout << endl;
}
bool isLeafNode(int nodeid) {
if
(arrayOfBTNodes[nodeid].getLeftChildPtr() == 0
&&
arrayOfBTNodes[nodeid].getRightChildPtr() == 0)
return true;
return false;
}
int getNodeHeight(int nodeid) {
if (nodeid == -1 || isLeafNode(nodeid))
return 0;
int leftChildID = arrayOfBTNodes[nodeid].getLeftChildID(); // -1 if not exist
int rightChildID = arrayOfBTNodes[nodeid].getRightChildID(); // -1 if not exist
return max(getNodeHeight(leftChildID), getNodeHeight(rightChildID)) + 1;
}
int getTreeHeight() {
return getNodeHeight(0);
}
void assignLevelNumbers() {
Queue queue;
queue.enqueue(0);
arrayOfBTNodes[0].setLevelNum(0);
while (!queue.isEmpty()) {
int firstNodeInQueue = queue.dequeue();
int leftChildID = arrayOfBTNodes[firstNodeInQueue].getLeftChildID();
if (leftChildID != -1) {
queue.enqueue(leftChildID);
arrayOfBTNodes[leftChildID].setLevelNum(
arrayOfBTNodes[firstNodeInQueue].getLevelNum() + 1);
}
int
rightChildID =
arrayOfBTNodes[firstNodeInQueue].getRightChildID();
if (rightChildID != -1) {
queue.enqueue(rightChildID);
arrayOfBTNodes[rightChildID].setLevelNum(
arrayOfBTNodes[firstNodeInQueue].getLevelNum() + 1);
}
}
}
int getDepth(int nodeid) {
return arrayOfBTNodes[nodeid].getLevelNum();
}
bool checkCompleteBinaryTree() {
int height = getTreeHeight();
assignLevelNumbers();
for (int i = 0; i < numNodes;
i++) {
if
(isLeafNode(arrayOfBTNodes[i].getNodeId())) {
if (arrayOfBTNodes[i].getLevelNum() != height)
{
return false;
}
} else {
if (arrayOfBTNodes[i].getLeftChildID() ==
-1
||
arrayOfBTNodes[i].getRightChildID() == -1) {
return false;
}
}
}
return true;
}
};
int main() {
string filename;
cout << "Enter a file name: ";
cin >> filename;
int numNodes;
cout << "Enter number of nodes: ";
cin >> numNodes;
BinaryTree binaryTree(numNodes);
ifstream fileReader(filename);
if (!fileReader) {
cout << "File cannot be opened!! ";
return 0;
}
int numCharsPerLine = 10;
char *line = new char[numCharsPerLine];
// '10' is the maximum number of characters per line
fileReader.getline(line, numCharsPerLine, '\n');
// '\n' is the delimiting character to stop reading the line
while (fileReader) {
char *cptr = strtok(line, ",: ");
string upstreamNodeToken(cptr);
int upstreamNodeID = stoi(upstreamNodeToken);
cptr = strtok(NULL, ",: ");
int childIndex = 0; // 0 for left child; 1 for right child
while (cptr != 0) {
string downstreamNodeToken(cptr);
int downstreamNodeID = stoi(downstreamNodeToken);
if (childIndex == 0 && downstreamNodeID != -1)
binaryTree.setLeftLink(upstreamNodeID, downstreamNodeID);
if (childIndex == 1 && downstreamNodeID != -1)
binaryTree.setRightLink(upstreamNodeID, downstreamNodeID);
cptr = strtok(NULL, ",: ");
childIndex++;
}
fileReader.getline(line, numCharsPerLine, '\n');
}
if (binaryTree.checkCompleteBinaryTree())
cout << "The binary tree is a complete binary tree " << endl;
else
cout << "The binary tree is not a complete binary tree " << endl;
system("pause");
return 0;
}
Program screenshot of the method checkCompleteBinaryTree:
Screenshot of the file content along with the output of and in-complete Binary tree:
Screenshot of the file content along with the output of a complete Binary tree:
Please provide a feedback by clicking on the feedback button
TJI 432 - 433 bool checkCompleteBinaryTree() { int height = getTreeHeight(); assignLevel Numbers(); for (int i = 0; i < numNodes; i++) { if (isLeaf Node(arrayOfBTNodes[i].getNodeId())) { if (arrayOfBTNodes[i].getLevel Num() != height) { return false; 435 436 437 438 439 440- 441 442 443 444 445 446 447 448 449 450 } else { if (arrayOfBTNodes[i].getLeftChildIDO) == -1 || arrayOfBTNodes[i].getRightChildID() == -1) { return false; return true;
main.cpp testfile.txt 1 0,1,2 2 1,3,4 3 2,5,6 4 3,7,8 5 4,9,10 6 5,11,12 7 6,13 input Enter a file name: testfile.txt Enter number of nodes: 14 The binary tree is not a complete binary tree sh: 1: pause: not found ... Program finished with exit code o Press ENTER to exit consa
main.cpp testfile.txt 1 0,1,2 2 1,3,4 3 2,5,6 4 3,7,8 5 4,9,10 6 5,11,12 7 6,13,14 input Enter a file name: testfile.txt Enter number of nodes: 15 The binary tree is a complete binary tree sh: 1: pause: not found - ... Program finished with exit code o Press ENTER to exit console.
Add Answer to:
A binary tree is a complete binary tree if all the internal
nodes (including the root...
in c++ please program for this code #include <iostream> #include <fstream> #include <string> #include <cstring> //...
in
c++ please
program for this code
#include <iostream>
#include <fstream>
#include <string>
#include <cstring> // for string tokenizer and c-style
string processing
#include <algorithm> // max function
#include <stdlib.h>
#include <time.h>
using namespace std;
// Extend the code here as needed
class BTNode{
private:
int nodeid;
int data;
int levelNum;
BTNode* leftChildPtr;
BTNode* rightChildPtr;
public:
BTNode(){}
void setNodeId(int id){
nodeid = id;
}
int getNodeId(){
return nodeid;
}
void setData(int d){
data = d;
}
int getData(){
return data;...
#include <iostream> #include <string> #include <cstring> using namespace std; class Node{ private: ...
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class Node{
private:
int data;
Node* nextNodePtr;
public:
Node(){}
void setData(int d){
data = d;
}
int getData(){
return
data;
}
void setNextNodePtr(Node*
nodePtr){
nextNodePtr = nodePtr;
}
...
PLEASE CODE IN C++ AND MAKE IT COPYABLE! In this project, you will design and implement...
PLEASE CODE IN C++ AND MAKE IT COPYABLE! In this project, you will design and implement an algorithm to determine the next greater element of an element in an array in Θ(n) time, where 'n' is the number of elements in the array. You could use the Stack ADT for this purpose. The next greater element (NGE) for an element at index i in an array A is the element that occurs at index j (i < j) such that...
In this assignment, you will use a Hashtable to determine the common elements in all the...
In this assignment, you will use a Hashtable to determine the
common elements in all the lists. If an element appears more than
once in one or more lists, the algorithm should capture the
instances the element is present in all the lists.
You are given a code that implements a Hashtable as an array of
linked lists. You are also given a main function that will create
an array of Lists using the input variable values that you enter....
#include <iostream> using namespace std; struct ListNode { float value; ListNode *next; }; ...
#include <iostream> using namespace std; struct ListNode { float value; ListNode *next; }; ListNode *head; class LinkedList { public: int insertNode(float num); void deleteNode(float num); void destroyList(); void displayList(); LinkedList(void) {head = NULL;} ~LinkedList(void) {destroyList();} }; int LinkedList::insertNode(float num) { struct ListNode *newNode, *nodePtr = head, *prevNodePtr = NULL; newNode = new ListNode; if(newNode == NULL) { cout << "Error allocating memory for new list member!\n"; return 1; } newNode->value = num; newNode->next = NULL; if(head==NULL) { cout << "List...
Removing Nodes from a Binary Tree in Java This section requires you to complete the following...
Removing Nodes from a Binary Tree in Java This section requires you to complete the following method within BinaryTree.java: public void remove(K key) { } The remove method should remove the key from the binary tree and modify the tree accordingly to maintain the Binary Search Tree Principle. If the key does not exist in the binary tree, no nodes should be removed. In case there is a non-null left child, it should take the place of the removed node....
Hi there, I am working on a binary search tree code in c++. The program must...
Hi there, I am working on a binary search tree code in c++. The program must store and update students' academic records, each node includes the student name, credits attempted, credits earned and GPA. I have made some progress with the code and written most of the functions in the .cpp file (already did the .h file) but i am struggling with what to put in the main and how to put an update part in the insert function. I...
Consider the class specifications for the Binary Tree class and Binary Search Tree class in the...
Consider the class specifications for the Binary Tree class and Binary Search Tree class in the attached files // BinaryTree.h #include <iostream> using namespace std; //Definition of the Node template <class elemType> struct TreeNode { elemType data; TreeNode<elemType> *left; TreeNode<elemType> *right; }; //Definition of class Binary Tree template <class elemType> class BinaryTree { protected: TreeNode<elemType> *root; public: BinaryTree(); BinaryTreel const BinaryTree<elemType>& otherTree); BinaryTree(); bool is Empty() const; virtual boot search(const elemType& searchItem) const = 0; virtual void insert(const elemType& insertItem)...
Write a function, swapSubtrees, that swaps all of the left and right subtrees of a binary...
Write a function, swapSubtrees, that swaps all of the left and right subtrees of a binary tree. Add this function to the class binaryTreeType and create a program to test this function. #include <iostream> using namespace std; //Definition of the Node template <class elemType> struct nodeType { elemType info; nodeType<elemType> *lLink; nodeType<elemType> *rLink; }; //Definition of the class template <class elemType> class binaryTreeType { public: //Overload the assignment operator. const binaryTreeType<elemType>& operator=(const binaryTreeType<elemType>&) { if (this != &otherTree) //avoid self-copy...
Test Data would be as follows: Using java language. Build an expression tree. • When you...
Test Data would be as follows:
Using java language. Build an expression tree. • When you see a number: o you create a new node with the number as the data. o Then you push the new node to the stack. . When you see a binary operator: 0 You create a new Node for the operator. Then you pop and set the right child. Then you pop and set the left child o Then you push the new node...
in
c++ please
program for this code
#include <iostream>
#include <fstream>
#include <string>
#include <cstring> // for string tokenizer and c-style
string processing
#include <algorithm> // max function
#include <stdlib.h>
#include <time.h>
using namespace std;
// Extend the code here as needed
class BTNode{
private:
int nodeid;
int data;
int levelNum;
BTNode* leftChildPtr;
BTNode* rightChildPtr;
public:
BTNode(){}
void setNodeId(int id){
nodeid = id;
}
int getNodeId(){
return nodeid;
}
void setData(int d){
data = d;
}
int getData(){
return data;...
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class Node{
private:
int data;
Node* nextNodePtr;
public:
Node(){}
void setData(int d){
data = d;
}
int getData(){
return
data;
}
void setNextNodePtr(Node*
nodePtr){
nextNodePtr = nodePtr;
}
...
In this assignment, you will use a Hashtable to determine the
common elements in all the lists. If an element appears more than
once in one or more lists, the algorithm should capture the
instances the element is present in all the lists.
You are given a code that implements a Hashtable as an array of
linked lists. You are also given a main function that will create
an array of Lists using the input variable values that you enter....
Consider the class specifications for the Binary Tree class and Binary Search Tree class in the attached files // BinaryTree.h #include <iostream> using namespace std; //Definition of the Node template <class elemType> struct TreeNode { elemType data; TreeNode<elemType> *left; TreeNode<elemType> *right; }; //Definition of class Binary Tree template <class elemType> class BinaryTree { protected: TreeNode<elemType> *root; public: BinaryTree(); BinaryTreel const BinaryTree<elemType>& otherTree); BinaryTree(); bool is Empty() const; virtual boot search(const elemType& searchItem) const = 0; virtual void insert(const elemType& insertItem)...
Test Data would be as follows:
Using java language. Build an expression tree. • When you see a number: o you create a new node with the number as the data. o Then you push the new node to the stack. . When you see a binary operator: 0 You create a new Node for the operator. Then you pop and set the right child. Then you pop and set the left child o Then you push the new node...
Most questions answered within 3 hours.
-
A market research firm reported that the mean annual earning of
all family practitioners in the...
asked 5 minutes ago -
How does organizational behavior typically differ in a
centralized organization vs. in a decentralized organization? Based...
asked 8 minutes ago -
[2] What happens when you try to create a hard link to a
directory? [2] Create...
asked 13 minutes ago -
Construct a molecular orbital diagram for the formation of N2; show
only the valence orbitals of...
asked 13 minutes ago -
In choosing what music to play at a charity fund raising event,
Cory needs to have...
asked 15 minutes ago -
When a heating a coil made of 34.0 m of 1.0 mm diameter Nichrome
wire is...
asked 27 minutes ago -
Charles Lackey operates a bakery in Idaho Falls, Idaho. Because
of its excellent product and excellent...
asked 31 minutes ago -
Demonstrate from planetary data that the speeds of out orbiters
are lower then inner orbiters.
asked 42 minutes ago -
C++ Programming question
For this exercise, you will receive two string inputs, which are
the names...
asked 41 minutes ago -
A person borrowed $30000 to finance the purchase of a new
vehicle. The loan will be...
asked 49 minutes ago -
during one repetition max squat all the ATP is being provided by
the immediate energy system....
asked 49 minutes ago -
A researcher observed three students on the playground. She
recorded the number of times each student...
asked 50 minutes ago