Question

C++ There is a premade heap.h file. You will write a program that creates a heap, and then asks the user to enter values which you will put in the heap (at least 8), and then display the heap

Then your program will display a menu with the following choices, and perform the appropriate actions

1. Display the heap

2. Add an item to the heap

3. Remove the largest item

4. Exit

The program will continue until the user chooses to exit, at which time it will display the heap and exit (and yes, you should have input validation)

heap.h****************************************************************************************************

#ifndef HEAP_H
#define HEAP_H

template <typename datatype>
class heap
{
public:
        void insert(datatype); //inserts at the end, rearranges to keep a heap
        void display(ostream &); //displays the heap
        void removeTop();//removes the top value, rearranges to keep a heap
        datatype top();  //returns the value at the top
        datatype getValue(int); //returns the value at a certain position
        bool empty();  //returns true if the heap is empty
        heap();                 // default constructor
        heap(int);              // constructor passing in size of array
        heap(datatype[], int);  // constructor, passing in array, and size
        ~heap(); //destructor

private:
        void percolateDown(int);
        void percolateUp(int);
        int size=0;
        int maxSize;
        int * myHeap;
};

template <typename datatype>
datatype heap<datatype>::getValue(int position)
{
        return myHeap[position];
}

template <typename datatype>
bool heap<datatype>::empty()
{
        return size == 0;
}
template <typename datatype>
heap<datatype>::heap()
{
        maxSize = 100;
        myHeap= new datatype[maxSize + 1];
}

template <typename datatype>
heap<datatype>::heap(int size)
{
        maxSize = size;
        myHeap = new datatype[maxSize + 1];
}

template <typename datatype>
heap<datatype>::heap(datatype orig[], int arrSize)
{
        maxSize = arrSize*2;
        myHeap = new datatype[maxSize];
        for (int i = 0; i < arrSize; i++)
                insert(orig[i]);
}

template <typename datatype>
heap<datatype>::~heap()
{
        delete []  myHeap;
}

template <typename datatype>
void heap<datatype>::insert(datatype entry)
{
        if (size < maxSize)
        {
                size++;
                myHeap[size] = entry;
                percolateUp(size);
        }
        else
                cout << "No room, couldn't insert\n";
}

template <typename datatype>
void heap<datatype>::percolateUp(int position)
{
        bool done = false;
        while (position/2 > 0 &&!done)
        {
                if (myHeap[position / 2] < myHeap[position])
                {
                        datatype temp = myHeap[position / 2];
                        myHeap[position/2] = myHeap[position];
                        myHeap[position] = temp;
        
                        position = position / 2;
                }
                else
                        done = true;
        }
}

template <typename datatype>
void heap<datatype>::display(ostream &out)
{
        for (int i = 1; i < size + 1; i++)
        {
                cout << myHeap[i] << ' ';
        }
        cout << endl;
}

template <typename datatype>
void heap<datatype>::removeTop()
{
        if (size > 0)
        {
                myHeap[1] = myHeap[size];
                size--;
                percolateDown(1);
        }
        else
                cout << "Heap empty, nothing to remove\n";
}

template <typename datatype>
void heap<datatype>::percolateDown(int position)
{
        if (position * 2 > size)    // no children
                return;

        //set 'bigger child' to be left-child
        int bigChild = position * 2;

        if (position * 2 < size)             //if 2 children
        {   //if right > left, set 'bigger child' to be right
                if (myHeap[position * 2 + 1]>myHeap[position * 2])
                        bigChild++;
        }
        //swap value with that of bigger child, IF NECESSARY
        if (myHeap[bigChild] > myHeap[position])
        {
                //swap value with that of bigger child
                datatype temp = myHeap[position];
                myHeap[position] = myHeap[bigChild];
                myHeap[bigChild] = temp;

                // call percolateDown with the new position (bigChild);
                percolateDown(bigChild);
        }
}
template <typename datatype>
datatype heap<datatype>::top()
{
        if (size>0)
                return myHeap[1];
        datatype junk;
        return junk;
}
#endif

Answer 1

//heap.h

#ifndef HEAP_H
#define HEAP_H
#include<iostream>
using namespace std;
template <typename datatype>
class heap
{
public:
void insert(datatype); //inserts at the end, rearranges to keep a heap
void display(ostream &); //displays the heap
void removeTop();//removes the top value, rearranges to keep a heap
datatype top(); //returns the value at the top
datatype getValue(int); //returns the value at a certain position
bool empty(); //returns true if the heap is empty
heap(); // default constructor
heap(int); // constructor passing in size of array
heap(datatype[], int); // constructor, passing in array, and size
~heap(); //destructor

private:
void percolateDown(int);
void percolateUp(int);
int size=0;
int maxSize;
int * myHeap;
};

template <typename datatype>
datatype heap<datatype>::getValue(int position)
{
return myHeap[position];
}

template <typename datatype>
bool heap<datatype>::empty()
{
return size == 0;
}
template <typename datatype>
heap<datatype>::heap()
{
maxSize = 100;
myHeap= new datatype[maxSize + 1];
}

template <typename datatype>
heap<datatype>::heap(int size)
{
maxSize = size;
myHeap = new datatype[maxSize + 1];
}

template <typename datatype>
heap<datatype>::heap(datatype orig[], int arrSize)
{
maxSize = arrSize*2;
myHeap = new datatype[maxSize];
for (int i = 0; i < arrSize; i++)
insert(orig[i]);
}

template <typename datatype>
heap<datatype>::~heap()
{
delete [] myHeap;
}

template <typename datatype>
void heap<datatype>::insert(datatype entry)
{
if (size < maxSize)
{
size++;
myHeap[size] = entry;
percolateUp(size);
}
else
cout << "No room, couldn't insert\n";
}

template <typename datatype>
void heap<datatype>::percolateUp(int position)
{
bool done = false;
while (position/2 > 0 &&!done)
{
if (myHeap[position / 2] < myHeap[position])
{
datatype temp = myHeap[position / 2];
myHeap[position/2] = myHeap[position];
myHeap[position] = temp;
  
position = position / 2;
}
else
done = true;
}
}

template <typename datatype>
void heap<datatype>::display(ostream &out)
{
for (int i = 1; i < size + 1; i++)
{
cout << myHeap[i] << ' ';
}
cout << endl;
}

template <typename datatype>
void heap<datatype>::removeTop()
{
if (size > 0)
{
myHeap[1] = myHeap[size];
size--;
percolateDown(1);
}
else
cout << "Heap empty, nothing to remove\n";
}

template <typename datatype>
void heap<datatype>::percolateDown(int position)
{
if (position * 2 > size) // no children
return;

//set 'bigger child' to be left-child
int bigChild = position * 2;

if (position * 2 < size) //if 2 children
{ //if right > left, set 'bigger child' to be right
if (myHeap[position * 2 + 1]>myHeap[position * 2])
bigChild++;
}
//swap value with that of bigger child, IF NECESSARY
if (myHeap[bigChild] > myHeap[position])
{
//swap value with that of bigger child
datatype temp = myHeap[position];
myHeap[position] = myHeap[bigChild];
myHeap[bigChild] = temp;

// call percolateDown with the new position (bigChild);
percolateDown(bigChild);
}
}
template <typename datatype>
datatype heap<datatype>::top()
{
if (size>0)
return myHeap[1];
datatype junk;
return junk;
}
#endif
//main.cpp

#include"heap.h"
#include<iostream>
using namespace std;

int main(){
   heap<int> h(20);
   int num;
   int data;
   int choice;
   cout<<"Enter number of integer element want to put in heap (atleast 8): ";
   cin>>num;
   cout<<"Enter elements in heap\n";
   for(int i=0;i<num;i++){
       cin>>data;
       h.insert(data);
   }
  
   do{
       cout<<"\n(1)Display the heap\n(2)Add an item to the heap\n(3)Remove the largest item\n(4)Exit\n";
       cout<<"Enter choice : ";
       cin>>choice;
       switch(choice){
           case 1:{
               cout<<"heap\n";
               h.display(cout);
               break;
           }
           case 2:{
               cout<<"Enter data : ";
               cin>>data;
               h.insert(data);
               break;
           }
           case 3:{
               cout<<"largest element : "<<h.top()<<" is removed\n\n";
               h.removeTop();
               break;
           }
           case 4:{
               cout<<"Thank you\n";
               break;
           }
           default:{
               cout<<"Invalid input\n";
               break;
           }
       }
      
   }while(choice!=4);
  
   return 0;
  
}

//sample output