In C++ Follow all code styling and submission instructions a.pdf

In C++
Follow all code styling and submission instructions as outlined for previous labs. Write a program
to do the following: Use the same input seed data you used for Lab 4 (your BST homework) as
seed input data into a hash table. Declare a hash table of size 29 elements. To hash your currency
objects into the hash table, use the pseudorandom hash scheme - (m*w + n*f) % size - where size
= 29, m = 2, n = 3, w = whole value, f = fractional value. For collision resolution, use quadratic
probing in the same direction always. Remember to circle around to the start of the array if
needed. Your main will first load the data into the hash table and print the number of data items
loaded, load factor and number of collisions. Then it will ask the user in a loop to enter a Krone to
search for. If the Krone object is found in the hash table, it will print the index where found,
otherwise it will print 'Invalid Data'. Then it will ask the user if they want to check again or end the
program. To submit, upload your code files and screenshot of the console only. For
documentation, only name blocks and existing documentation in your Krone class are needed.
#include<iostream>
#include<fstream>
using namespace std;
class Node
{
public:
float value;
Node * left;
Node * right;
Node (float value)
{
this->value = value;
right = NULL;
left = NULL;
}
};
int
main ()
{
BST bst;

ofstream outputFile ("output.txt");
// Seed the tree with 20 Krone objects
bst.insertNode (Krone (57, 12));
// Perform breadth-first traversal
queue < BSTNode * >bfsQueue;

bfsQueue.push (bst.getRoot ());
while (!bfsQueue.empty ())
{
BSTNode * currNode = bfsQueue.front ();
bfsQueue.pop ();
if (currNode != nullptr)
{
cout << currNode->getData () << " ";
outputFile << currNode->getData () << " ";
bfsQueue.push (currNode->getLeft ());
bfsQueue.push (currNode->getRight ());
}
}
cout << endl;
outputFile << endl;
// Perform in-order traversal
bst.printInOrder (outputFile);
// Perform pre-order traversal
bst.printPreOrder (outputFile);
// Perform post-order traversal
bst.printPostOrder (outputFile);
// Interactivity for adding/searching/deleting nodes
char choice;
do
{

cout <<
"nEnter 'a' to add a Krone object, 's' to search for a Krone object, 'd' to delete a Krone object, 'p' to
print data, or 'q' to quit: ";
cin >> choice;
if (choice == 'a')
{
Krone krone;
cout << "Enter a Krone object in the format 'x.y': ";
cin >> krone;
if (cin.fail ())
{
cout << "Invalid input. Ignoring this Krone object." << endl;
cin.clear ();
cin.ignore (numeric_limits < streamsize >::max (), 'n');
}
else
{
bst.insertNode (krone);
cout << "Krone object added." << endl;
}
}
else if (choice == 's')
{
Krone krone;
cout << "Enter a Krone object to search for in the format 'x.y': ";
cin >> krone;
if (cin.fail ())
{
cout << "Invalid input. Ignoring this Krone object." << endl;

cin.clear ();
cin.ignore (numeric_limits < streamsize >::max (), 'n');
}
else
{
BSTNode * foundNode = bst.searchNode (krone);
if (foundNode == nullptr)
{
cout << "Krone object not found
}
class BinaryTree
{
private:
Node * insertHelper (Node * current, float value)
{
if (current == NULL)
{
return new Node (value);
}
if (value < current->value)
{
current->left = insertHelper (current->left, value);
}
else if (value > current->value)
{
current->right = insertHelper (current->right, value);
}
else
{
return current;

}
return current;
}
bool searchNode (Node * current, float value)
{
if (current == NULL)
{
return false;
}
if (value == current->value)
{
return true;
}
return value < current->value ? searchNode (current->left,
value) :
searchNode (current->right, value);
}
Node * deleteHelper (Node * root, float key)
{
if (root == NULL)
return root;
if (key < root->value)
root->left = deleteHelper (root->left, key);
else if (key > root->value)
root->right = deleteHelper (root->right, key);
else
{

if (root->left == NULL)
return root->right;
else if (root->right == NULL)
return root->left;
root->value = minValue (root->right);
root->right = deleteHelper (root->right, root->value);
}
return root;
}
public:
Node * root;
void insert (float value)
{
root = insertHelper (root, value);
}
bool find (int value)
{
return searchNode (root, value);
}
void update (float old, float new_)
{
if (this->find (old))
{
this->delete_ (old);

this->insert (new_);
}
cout << "Element to be updated not found";
}
int minValue (Node * root)
{
int min = root->value;
while (root->left != NULL)
{
min = root->left->value;
root = root->left;
}
return min;
}
void delete_ (int key)
{
root = deleteHelper (root, key);
}
void postOrder (Node * node)
{
if (node != NULL)
{

postOrder (node->left);
postOrder (node->right);
cout << " " << node->value;
}
}
void preOrder (Node * node)
{
if (node != NULL)
{
preOrder (node->left);
preOrder (node->right);
}
}
void inOrder (Node * node)
{
if (node != NULL)
{
inOrder (node->left);
inOrder (node->right);
}
}

};
int
main ()
{
BinaryTree bt;
ifstream file;
file.open ("input.txt");
if (!file.is_open ())
{
cout << "File not found check file info" << endl;
}
else
{
string temp;
while (getline (file, temp))
{
temp.replace (0, 1, "");
float value = stof (temp);
bt.insert (value);
}
}
bt.preOrder (bt.root);
bt.postOrder (bt.root);
bt.inOrder (bt.root);
file.close ();
return 0;
}
#ifndef Krone_H
#define Krone_H
#include <iostream>

#include "currency.cpp"
// derived class Krone from Currency class
class Krone : public Currency
{
private:
string currencyName;
public:
Krone()
{
currencyName = "Krone";
}
Krone(double value) : Currency(value)
{
currencyName = "Krone";
}
void print()
{
Currency::print();
cout << " " << currencyName << " ";
}
};
#endif

In C++ Follow all code styling and submission instructions a.pdf

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a In C++ Follow all code styling and submission instructions a.pdf

Semelhante a In C++ Follow all code styling and submission instructions a.pdf (20)

Mais de adithyaups

Mais de adithyaups (20)

Último

Último (20)

In C++ Follow all code styling and submission instructions a.pdf