Can you finish and write the int main for the code according to the instruction Thank you so much.

Here's the code for the BSTNode ADT and BST implementation:

#include

#include

#include

using namespace std;

// Krone class

class Krone {

private:

int wholeValue;

int fractionalValue;

public:

Krone() {}

Krone(int whole, int fraction) : wholeValue(whole), fractionalValue(fraction) {}

int getWhole() const { return wholeValue; }

int getFraction() const { return fractionalValue; }

bool operator<(const Krone& other) const {

if (wholeValue < other.wholeValue) {

return true;

} else if (wholeValue == other.wholeValue) {

return fractionalValue < other.fractionalValue;

} else {

return false;

}

}

friend ostream& operator<<(ostream& out, const Krone& krone) {

out << "Kr " << krone.wholeValue << "." << krone.fractionalValue;

return out;

}

};

// BST Node class

class BSTNode {

private:

Krone data;

BSTNode* left;

BSTNode* right;

public:

BSTNode() {}

BSTNode(const Krone& krone) : data(krone), left(nullptr), right(nullptr) {}

Krone getData() const { return data; }

BSTNode* getLeft() const { return left; }

BSTNode* getRight() const { return right; }

void setData(const Krone& krone) { data = krone; }

void setLeft(BSTNode* node) { left = node; }

void setRight(BSTNode* node) { right = node; }

};

// BST class

class BST {

private:

BSTNode* root;

public:

BST() : root(nullptr) {}

BSTNode* getRoot() const { return root; }

bool isEmpty() const { return root == nullptr; }

int countNodes(BSTNode* node) const {

if (node == nullptr) {

return 0;

} else {

return 1 + countNodes(node->getLeft()) + countNodes(node->getRight());

}

}

void empty(BSTNode* node) {

if (node != nullptr) {

empty(node->getLeft());

empty(node->getRight());

delete node;

}

}

void insertNode(const Krone& krone) {

BSTNode* node = new BSTNode(krone);

if (isEmpty()) {

root = node;

} else {

BSTNode* currNode = root;

while (true) {

if (krone < currNode->getData()) {

if (currNode->getLeft() == nullptr) {

currNode->setLeft(node);

break;

} else {

currNode = currNode->getLeft();

}

} else {

if (currNode->getRight() == nullptr) {

currNode->setRight(node);

break;

} else {

currNode = currNode->getRight();

}

}

}

}

}

BSTNode* searchNode(const Krone& krone) const {

BSTNode* currNode = root;

while (currNode != nullptr) {

Declare and implement a BSTNode ADT with a data attribute and two pointer attributes, one for the left child and the other for the right child. Implement the usual getters/setters for these attributes.

Declare and implement a BST as a link-based ADT whose data will be Krone objects - the data will be inserted based on the actual money value of your Krone objects as a combination of the whole value and fractional value attributes.

For the BST, implement the four traversal methods as well as methods for the usual search, insert, delete, print, count, isEmpty, empty operations and any other needed.

Your pgm will use the following 20 Krone objects to be created in the exact order in your main to seed the tree:

Kr 57.12

Kr 23.44

Kr 87.43

Kr 68.99

Kr 111.22

Kr 44.55

Kr 77.77

Kr 18.36

Kr 543.21

Kr 20.21

Kr 345.67

Kr 36.18

Kr 48.48

Kr 101.00

Kr 11.00

Kr 21.00

Kr 51.00

Kr 1.00

Kr 251.00

Kr 151.00

Also, create an output file to write program output as specified in one or more instructions below.

After seeding the data, perform your traversal operations in the specific sequence of breadth-first, in-order, pre-order, post-order, ensuring that output is written out to both screen and file concurrently.

Then provide interactivity for the user to add/search/delete nodes from the console after the data has been seeded into the application.

Perform adequate input data validation when reading data from the user into the tree - if any data item is invalid, ignore the data item and continue to next item but print a message to output (both screen and same output file) to indicate which data items were ignored.

Also, provide the user the option to print output of traversals or exit the program. Once the user selects the option to print data or exits the program, the data in the BST should be printed out to both screen and output file in all four traversal methods in the specific sequence of breadth-first, in-order, pre-order, post-order.

For submission - upload all code files necessary to make your program run (not just your BST, Krone and main code files) as well as screenshots of console window and your output files only.