Question

I need help with this lab assignment. I use C++, thank you.

 

• Derive a MinHeap class from the BST class of your Lab 4 code.

• Define/Override only the Search/Insert/Delete methods in the new class.

• Write a new main for this lab which:

• Will only be a test program for the MinHeap.

• Declares and creates a MinHeap object as necessary.

• Declares and creates the Dollar objects as necessary.

• Inserts the 20 Dollar objects specified in Lab 4 in the same order.

• Performs all 4 traversals after the inserting the 10th and the last objects - in total there will be 8 outputs which should be clearly demarcated.

• No user input is necessary, no data validation is necessary.

• For submission - upload all class files from Lab 4 as necessary as well as your new MinHeap class and the main. Remember to also include adequate number of screenshots of the program execution.

 

My lab 4 code (you can edit it if you have to):

 

#include
#include
using namespace std;
class Node {
public:
       float value;
       Node *left;
       Node *right;
       Node(float value) {
               this->value = value;
               right = NULL;
               left = NULL;
       }
};

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) {
                       cout<<" "<< node->value;
                       preOrder(node->left);
                       preOrder(node->right);
               }
       }
       void inOrder(Node* node) {
               if (node != NULL) {
                       inOrder(node->left);
                       cout<<" "<< node->value;
                       inOrder(node->right);
               }
       }
};
int main(){
   BinaryTree bt;
   ifstream file;
   file.open("Currency.h");
   if(!file.is_open()){
       cout<<"File not found check file info"<   }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;
}