I attached the question. public int getHeight(){ return findHeight(root); } private int findHeight(Node root){ if(root==null){ return 0; } int leftHeight = findHeight(root.Left); int rightHeight =...

I attached the question.

public int getHeight(){
        return findHeight(root);
    }

    private int findHeight(Node root){
        if(root==null){
            return 0;
        }
        int leftHeight = findHeight(root.Left);
        int rightHeight = findHeight(root.Right);
        return Math.max(leftHeight,rightHeight)+1;
    }

    public int getLargestKey(){
        enrichLargest(root);
        return max;
    }

    public float getAverage(){
        enrichSum(root);
        enrichCount(root);
        return (float)sum/(float)count;
    }

    private void enrichCount(Node root) {
        if(root!=null){
            count++;

        enrichSum(root.Left);
        enrichSum(root.Right);
          }
    }

    private void enrichSum(Node root){
        if(root!=null){
            sum += root.item;

        enrichSum(root.Left);
        enrichSum(root.Right);
          }
    }
    private void enrichLargest(Node root){
        if(root!=null){
            max = Math.max(root.item,max);

        enrichLargest(root.Left);
        enrichLargest(root.Right);
          }
    }

    public boolean Delete(int key)
    {
        Node parent = null;
        Node curr = root;
        while (curr != null && curr.item != key)
        {
            parent = curr;
            if (key < curr.item)="">
                curr = curr.Left;
            } else {
                curr = curr.Right;
            }
        }

        if (curr == null) {
            return false;
        }
        if (curr.Left == null && curr.Right == null) {
            if (curr != root) {
                if (parent.Left == curr) {
                    parent.Left = null;
                }else{
                    parent.Right = null;
                }
            } else{
                root = null;
            }
        }
        else if (curr.Left != null && curr.Right != null) {
            Node successor = getSuccessor(curr.Right);
            int val = successor.item;
            Delete(successor.item);
            curr.item = val;
        }
        else {
            Node child = (curr.Left != null)? curr.Left: curr.Right;
            if (curr != root){
                if (curr == parent.Left) {
                    parent.Left = child;
                } else {
                    parent.Right = child;
                }
            } else {
                root = child;
            }
        }
        return true;
    }

    public Node getSuccessor(Node curr) {
        while (curr.Left != null) {
            curr = curr.Left;
        }
        return curr;
    }
    public void printOrderTraversal(Order order){
        switch(order){
            case IN_ORDER:
                InOrder(root);
                break;
            case PRE_ORDER:
                preOrder(root);
                break;
            case POST_ORDER:
                postOrder(root);
            default:
        }

    }
    public void InOrder(Node theRoot) {
        if (!(theRoot == null))
        {
            InOrder(theRoot.Left);
            theRoot.DisplayNode();
            InOrder(theRoot.Right);
        }
    }

    public void preOrder(Node theRoot) {
        if (!(theRoot == null))
        {
            theRoot.DisplayNode();
            preOrder(theRoot.Left);
            preOrder(theRoot.Right);
        }
    }

    public void postOrder(Node theRoot) {
        if (!(theRoot == null))
        {
            postOrder(theRoot.Left);
            postOrder(theRoot.Right);
            theRoot.DisplayNode();
        }
    }

    public class Node{
        public int item;
        public Node Left;
        public Node Right;
        public Node(int item) {
            this.item = item;
            Left=null;
            Right=null;
        }
        void DisplayNode(){
            System.out.println(this.item);
        }
    }
    public enum Order{
        PRE_ORDER,
        POST_ORDER,
        IN_ORDER
    }

}

Extracted text: Find the height of the BST. Find node with the largest key. Find the average of the key values of the nodes. d. a. b. C. Print the nodes in the tree in pre-order, in-order, and post-order. (decided by the user after run) Create the same BST shown in question 2. Run your program for the BST shown in question 1 to its final state and output the height, the largest key, and average of the keys. e.


Extracted text: 1 import java.util.*; 2 v public class Main{ 3 public static void main(String [] args){ BinarySearchTreel myTree = new BinarySearchTree1 (); 4. 6 7 8 myTree.Insert (1); 9. 10 int height=myTree.getHeight (); 11 12 int largestkey=myTree.getLargestkey (); 13 14 float myAvg=myTree.getAverage (); 15 16 17