Question

Description You are to create a class named BinaryTree. This will simulate a balanced and ordered binary tree. You also need to create a TreeNode class, which defines the data contained in each node of the tree. In this case, it is an integer. Remember that the node also needs a way to track back to its parent, as well as its left and right children. For the purpose of this assignment, each node should also contain an indication of its level within the tree For the TreeNode, the constructor only needs to obtain the integer value held in the node. The class should have modifiers to allow its placement on the tree; in other words, the ability to connect it to its parent and connect child nodes. Also have a modifier to change the level The BinaryTree class constructor will not receive any input. The class will have three methods add, remove, and find Add(int) receives an integer value, creates the new TreeNode, and adds it to the appropriate location on the tree, keeping it balanced. Use the algorithm available in the Web Links for assistance . . Remove(int) locates the desired value and removes it from the tree, balancing it afterwards. If the node does not exist, it does nothing. Use the algorithm available in the Web Links for assistance Find(int) receives the integer value desired, and returns the TreeNode of that item. It returns NULL if the item is not located. Note you may need some other Private methods (like rotate)) in order to keep the tree in balance

java

Answer 1

public class BinaryTree {

   class TreeNode {

       int key, height;

       TreeNode left, right;

       TreeNode(int d) {

           key = d;

           height = 1;

       }

   }

   TreeNode root;

   BinaryTree() {

       root = null;

   }

   int height(TreeNode N) {

       if (N == null)

           return 0;

       return N.height;

   }

   TreeNode RR(TreeNode y) {

       TreeNode x = y.left;

       TreeNode T2 = x.right;

       // Perform rotation

       x.right = y;

       y.left = T2;

       // Update heights

       y.height = Math.max(height(y.left), height(y.right)) + 1;

       x.height = Math.max(height(x.left), height(x.right)) + 1;

       // Return new root

       return x;

   }

   TreeNode LL(TreeNode x) {

       TreeNode y = x.right;

       TreeNode T2 = y.left;

       y.left = x;

       x.right = T2;

       x.height = Math.max(height(x.left), height(x.right)) + 1;

       y.height = Math.max(height(y.left), height(y.right)) + 1;

       return y;

   }

   int getBalanceFactor(TreeNode N) {

       if (N == null)

           return 0;

       return height(N.left) - height(N.right);

   }

   TreeNode add(TreeNode root, int data) {

       if (root == null)

           return (new TreeNode(data));

       if (data < root.key)

           root.left = add(root.left, data);

       else if (data > root.key)

           root.right = add(root.right, data);

       else

           return root;

       root.height = 1 + Math.max(height(root.left), height(root.right));

       int bal = getBalanceFactor(root);

       if (bal > 1 && data < root.left.key)

           return RR(root);

       if (bal < -1 && data > root.right.key)

           return LL(root);

       if (bal > 1 && data > root.left.key) {

           root.left = LL(root.left);

           return RR(root);

       }

       if (bal < -1 && data < root.right.key) {

           root.right = RR(root.right);

           return LL(root);

       }

       return root;

   }

   TreeNode minimumValue(TreeNode node) {

       TreeNode curr = node;

       while (curr.left != null)

           curr = curr.left;

       return curr;

   }

   TreeNode remove(TreeNode root, int data) {

       if (root == null)

           return root;

       if (data < root.key)

           root.left = remove(root.left, data);

       else if (data > root.key)

           root.right = remove(root.right, data);

       else {

           if ((root.left == null) || (root.right == null)) {

               TreeNode temp = null;

               if (temp == root.left)

                   temp = root.right;

               else

                   temp = root.left;

               if (temp == null) {

                   temp = root;

                   root = null;

               } else

                   root = temp;

           } else {

               TreeNode temp = minimumValue(root.right);

               root.key = temp.key;

               root.right = remove(root.right, temp.key);

           }

       }

       if (root == null)

           return root;

       root.height = Math.max(height(root.left), height(root.right)) + 1;

       int bal = getBalanceFactor(root);

       if (bal > 1 && getBalanceFactor(root.left) >= 0)

           return RR(root);

       if (bal > 1 && getBalanceFactor(root.left) < 0) {

           root.left = LL(root.left);

           return RR(root);

       }

       if (bal < -1 && getBalanceFactor(root.right) <= 0)

           return LL(root);

       if (bal < -1 && getBalanceFactor(root.right) > 0) {

           root.right = RR(root.right);

           return LL(root);

       }

       return root;

   }

   void inOrder(TreeNode node) {

       if (node != null) {

          

           inOrder(node.left);

           System.out.print(node.key + " ");

           inOrder(node.right);

       }

   }

   public TreeNode Find(TreeNode root, int data)

   {

      if (root==null || root.key==data)

      return root;

      if (root.key > data)

      return Find(root.left, data);

      return Find(root.right, data);

   }

   public static void main(String[] args) {

       BinaryTree aVLTree = new BinaryTree();

       for (int i = 1; i <= 5; ++i) {

           aVLTree.root = aVLTree.add(aVLTree.root, i);

       }

       System.out.println("Original Tree");

       aVLTree.inOrder(aVLTree.root);

       aVLTree.root = aVLTree.remove(aVLTree.root, 4);

       System.out.println("\nAfter Removing 4");

       aVLTree.inOrder(aVLTree.root);

      

       if(aVLTree.Find(aVLTree.root, 5) != null)

           System.out.println("\nNode with value 5 is found");

       else

           System.out.println("\nNode with value 5 is NOT found");

   }

}

===========================
See Output


Thanks, PLEASE UPVOTE if helpful