Question

Write a C program insertion and deletion functions for a max heap represented as a linked binary tree.

Assume that each node has a parent field as well as the usual left child, right child, and key fields.

-Condition : Do not use Array representation. Use the following structure.

typedef struct node *treePointer;

typedef struct node {

int key;

treePointer parent;

treePointer leftChild, rightChild;

};

- INPUT

i k : Insert the node with the key value of k in the heap.

d : Delete the node with the largest key in the heap.

q : End the program.

- OUTPUT

  Insert k : If i k is operating successfully

Exist number : If i k fails (if it is already a key value that exists)

Delete k : If d worked successfully

The heap is empty : if d fails (if the heap is empty)

- Exmple

input / output

i 4 / Insert 4

i 4 / Exist number

i 5 / Insert 5

d / Delete 5

d / Delete 4

d / The heap is empty

i 3 / Insert 3

q

Answer 1

#include<iostream>
#include<math.h>
using namespace std;
typedef struct node * treePointer;

struct node {
int key;

treePointer parent;

treePointer leftChild, rightChild;
};
treePointer root=nullptr;
int heapSize=0;
treePointer lastParent=nullptr;
treePointer deleteParent=nullptr;
int index=0;
int check(treePointer root, int a)
{
   if(!root)
       return 0;
   if(root->key==a)
       return 1;
   else
   return check(root->leftChild,a)+check(root->rightChild,a);
}

void heapify(treePointer ptr)
{
   if(!ptr)
       return;
   //left is greater
   if(ptr->leftChild)
   {
   if((ptr->leftChild->key)>(ptr->key))
   {
   int i;
       i=ptr->leftChild->key;
       ptr->leftChild->key=ptr->key;
       ptr->key=i;
      
   }
   }
   if(ptr->rightChild){
   if(ptr->rightChild->key>ptr->key)
   {
   int i;
       i=ptr->rightChild->key;
       ptr->rightChild->key=ptr->key;
       ptr->key=i;
      
   }
   }
   heapify(ptr->parent);
}
void last_parent(treePointer pt,int lev)
{
  
   if(!pt || lev==0)
       return ;
   if(lev==1)
   {
       if(pt->leftChild==nullptr || pt->rightChild==nullptr)
       { index++;
       if(index==1)
       {
       lastParent=pt;
       return ;
       }
       return;
       }
   }
   else {
   last_parent(pt->leftChild,lev-1);
   last_parent(pt->rightChild,lev-1);
   }
   return;
}
treePointer last(treePointer temp)
{
   int level=ceil(log10(heapSize+1)/log10(2));
   index=0;
last_parent(temp,level-1);
   last_parent(temp,level);
   return lastParent;
}
bool insert(int a)
{
   if(root==nullptr)
   {
       treePointer temp=new node();
       temp->key=a;
       temp->parent=nullptr;
       temp->leftChild=nullptr;
       temp->rightChild=nullptr;
       root=temp;
       heapSize++;
       return true;
   }
   int n=check(root,a);
   if(n)
   {
       return false;
   }
   treePointer ptr=last(root);
   if(ptr!=nullptr)
   {
   //no left child
   if(ptr->leftChild==nullptr)
   {
       treePointer temp=new node();
       temp->key=a;
       temp->parent=ptr;
       temp->leftChild=nullptr;
       temp->rightChild=nullptr;
       ptr->leftChild=temp;
       heapSize++;
       heapify(ptr);
       return true;
   }
   //no right child
   treePointer temp=new node();
       temp->key=a;
       temp->parent=ptr;
       temp->leftChild=nullptr;
       temp->rightChild=nullptr;
       ptr->rightChild=temp;
       heapSize++;
       heapify(ptr);
       return true;
   }
   return false;
}
void lastDelete(treePointer pt, int level)
{
  
if (pt == nullptr)
return;
if (level == 1)
{
       deleteParent=pt;
       //cout<<pt->key<<endl;
   }
else if (level > 1)
{
lastDelete(pt->leftChild, level-1);
lastDelete(pt->rightChild, level-1);
}
}
void deleteHeapify(treePointer ptr)
{
if(!ptr)
return;
   if(ptr->leftChild)
   {
   if((ptr->leftChild->key)>(ptr->key))
   {
   int i;
       i=ptr->leftChild->key;
       ptr->leftChild->key=ptr->key;
   ptr->key=i;
      
   }
   }
   if(ptr->rightChild){
   if(ptr->rightChild->key>ptr->key)
   {
   int i;
       i=ptr->rightChild->key;
       ptr->rightChild->key=ptr->key;
       ptr->key=i;
      
   }
   }
   heapify(ptr->leftChild);
   heapify(ptr->rightChild);
}
  
int deleteMax()
{
if(!root && heapSize==0)
return -1;
int level=ceil(log10(heapSize+1)/log10(2));
lastDelete(root,level);
treePointer ptr=deleteParent;
if(ptr==root)
{ int i=root->key;
delete root;
heapSize--;
root=nullptr;
return i;
}
if(ptr)
{
       int i;
       i=ptr->key;
       ptr->key=root->key;
       root->key=i;
       i=ptr->key;
       if(ptr->parent->rightChild==ptr)
       ptr->parent->rightChild=nullptr;
       else if(ptr->parent->leftChild==ptr)
       ptr->parent->leftChild=nullptr;
       delete ptr;
       deleteHeapify(root);
       heapSize--;
       return i;
   }
}
int main()
{
   char choice;
   int num;
   int max;
   while(1){
   cin>>choice;
   switch(choice)
   {
   case 'i' : cin>>num;
   if(insert(num))
   cout<<"Insert "<<num<<endl;
   else
   cout<<"Exist number "<<num<<endl;
   // cout<<heapSize<<endl;
   break;
   case 'd' : max=deleteMax();
   if(max<0)
   cout<<"The heap is empty"<<endl;
   else
   cout<<"Delete "<<max<<endl;
   // cout<<heapSize<<endl;
   break;
   case 'q' : deleteMax();
   cout<<root->key<<endl;
   return 0;
   }
   }
}
  
      

/*

Output

Insert 4
Exist number 4
Insert 5
Delete 5
Delete 4
The heap is empty
Insert 3

Input

i 4
i 4
i 5
d
d
d 
i 3
q

*/