a. Find the height of the BST. b. Find node with the largest key. Find the average of the key values of the nodes. c.

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
    }

}