Question

Write a C++ program that implements a binary search tree (BST) to manage a number of integer items with different priorities. In order to do so, you will need to maintain a queue as an item in the tree. Each queue item is an integer. All items in a given queue will have the same priority. As a new item with a user-specified priority comes in, it should be enqueued in the queue with items of that priority. A new queue may need to created in case a queue with that priority does not exist. Use dynamic memory to manage nodes in the queue and BST.

Answer 1

#include <iostream>
#include <stdlib.h>

using namespace std;

// Queue Operations
struct queue_node
{
   int key;
   struct queue_node* next;
};

void enqueue(struct queue_node* n, int key)
{
   struct queue_node* t = (struct queue_node*) malloc(sizeof(struct queue_node));
   t->key = key;
   t->next = NULL;
   while (n != NULL)
   {
       n = n->next;
   }
   n = t;

}

// Use this utility program just to show the data
int dequeue(struct queue_node* node)
{
   if (node != NULL)
   {
       int data = node->key;
       return data;
   }
}

bool isEmpty(struct queue_node* node)
{
   if (node == NULL)
   {
       return true;
   }
   else
       return false;
}

// Creating a struct node to use in the bst
typedef struct node
{
   struct queue_node* Q; // Queue to hold the values of the same priority
   int priority; // to determine the priority of the node
   struct node* left; // left children of this node
   struct node* right; // right children of this node
} Node;

// utility function to insert in the BST
void insert(Node* node, int key, int priority)
{
   if (node == NULL)
   {
       node = (Node*)malloc(sizeof(Node));
       node->Q = (struct queue_node*) malloc(sizeof(struct queue_node));
       node->Q->next = NULL;
       enqueue(node->Q, key);
       node->priority = priority;
       node->left = NULL;
       node->right = NULL;
       cout << "At priority " << priority << " data " << key << " has been inserted" << endl;
       return;
   }
   if (priority == -1)
   {
       enqueue(node->Q, key);
       node->priority = priority;
       cout << "At priority " << priority << " data " << key << " has been inserted" << endl;
       return;
   }

   if (node->priority == priority) // If we get the right priority we just enqueue the number
   {
       enqueue(node->Q, key);
       cout << "At priority " << priority << " data " << key << " has been inserted" << endl;
       return;
   }
   //If it is not null we search for the right place to insert the data on the basis of priority
   if (priority < node->priority) // if the priority is lesser we search in the left subtree
   {
       insert(node->left, key, priority);
   }
   else if (priority > node->priority) // if the priority is greater we search in the right subtree
   {
       insert(node->right, key, priority);
   }
   return;
}

// Driver Program
int main()
{
   Node* root = (Node*)malloc(sizeof(Node));
   root->left = NULL;
   root->right = NULL;
   root->priority = -1;
   root->Q = (struct queue_node*)malloc(sizeof(struct queue_node));
   root->Q->next = NULL;
   insert(root, 23, 1);
   insert(root, 324, 1);
   insert(root, 21, 2);
   insert(root, 435, 2);
   insert(root, 332, 2);
   insert(root, 212, 0);
   insert(root, 32, 3);
   insert(root, 31, 3);

   return 0;
}

OUTPUT