#include "BST.h"

/**
* constructor
*/
BST::BST() {
root = 0;
}

/**
* copy construtor
* @param o
*/
BST::BST(const BST& o) {
// clean();
root = 0;
if (o.root != 0) {
   root = o.root->treeCopy();
}
//root = 0;
}

/**
* destructor
*/
BST::~BST() {
clean();
}

/**
* tet for emptiness
* @return
*/
bool BST::isEmpty() const {
return root == 0;
}

/**
* find a node which has the same priority with the input
* @param prioriry
* @return
*/
node<queue>* BST::find(int prioriry) {
node<queue> * n = root;
int nPriority;
while (n != 0) {
   nPriority = n->data.getPriority();
   if (prioriry == nPriority) {
         return n;
   }
   if (prioriry > nPriority) {
         n = n->right;
   } else {
         n = n->left;
   }
}
return n;
}

/**
* insert a number to tree
* @param data
* @param prioriry
*/
void BST::insert(int data, int prioriry) {
if (root == 0) {
   root = new node<queue>();
   root->data.enqueue(data);
   root->data.setPriority(prioriry);
} else {
   node<queue> * n = root;
   int nPriority;
   while (n != 0) {
         nPriority = n->data.getPriority();
         if (prioriry == nPriority) {
            n->data.enqueue(data);
            break;
         }
         if (prioriry > nPriority) {
            if (n->right == 0) {
               n->right = new node<queue>();
               n->right->data.enqueue(data);
               n->right->data.setPriority(prioriry);
               break;
            }
            n = n->right;
         } else {
            if (n->left == 0) {
               n->left = new node<queue>();
               n->left->data.enqueue(data);
               n->left->data.setPriority(prioriry);
               break;
            }
            n = n->left;
         }
   }
}
}

6. Consider the following piece of code where a parent creates a c...