AVL trees

if (current.height != oldHeight && current.parent != null) {
            updateHeights(current.parent);
} 

if (current.height != oldHeight && current.parent != null) {
            updateHeights(current.parent);
} 

public boolean insertNode(int key, float value) throws IllegalArgumentException {
        if(value < 0  || findByKey(key) != -1f) {
            //returning false if node has a key that already exists or value is < 0
            return false;
        }
        AVLNode newNode;
        if (root == null){
                root = new AVLNode(key, value);
                updateHeights(root);
                size++;
                return true;
        }else {
            AVLNode current = root;
            while (true) {
                    int cmp = Integer.compare(current.key, key);
                    if (cmp == 0)
                        return false;
                    else if (cmp < 0) {
                        if (current.right != null)
                            current = current.right;
                        else {
                            newNode = new AVLNode(key, value);
                            setRight(current,newNode);
                            updateHeights(newNode);
                            size++;
                            break;
                        }
                    } else {
                        if (current.left != null)
                            current = current.left;
                        else {
                            newNode = new AVLNode(key, value);
                            setLeft(current, newNode);                 updateHeights(newNode);
                            size++;
                            break;
                        }}}}
        AVLNode n = newNode;

        while (n != null) {
            AVLNode x = n;
            if (x.parent != null && x.parent.parent != null && !isBalanced(x.parent.parent)) {
                AVLNode z = x.parent.parent;
                AVLNode y = x.parent;
                restructure(x, y, z);
                updateHeights(n);
            }else {
                n = n.parent;
            }
        }
        return true;
    } 

public boolean insertNode(int key, float value) throws IllegalArgumentException {
        if(value < 0  || findByKey(key) != -1f) {
            //returning false if node has a key that already exists or value is < 0
            return false;
        }
        AVLNode newNode;
        if (root == null){
                root = new AVLNode(key, value);
                updateHeights(root);
                size++;
                return true;
        }else {
            AVLNode current = root;
            while (true) {
                    int cmp = Integer.compare(current.key, key);
                    if (cmp == 0)
                        return false;
                    else if (cmp < 0) {
                        if (current.right != null)
                            current = current.right;
                        else {
                            newNode = new AVLNode(key, value);
                            setRight(current,newNode);
                            updateHeights(newNode);
                            size++;
                            break;
                        }
                    } else {
                        if (current.left != null)
                            current = current.left;
                        else {
                            newNode = new AVLNode(key, value);
                            setLeft(current, newNode);                 updateHeights(newNode);
                            size++;
                            break;
                        }}}}
        AVLNode n = newNode;

        while (n != null) {
            AVLNode x = n;
            if (x.parent != null && x.parent.parent != null && !isBalanced(x.parent.parent)) {
                AVLNode z = x.parent.parent;
                AVLNode y = x.parent;
                restructure(x, y, z);
                updateHeights(n);
            }else {
                n = n.parent;
            }
        }
        return true;
    } 

public void restructure(AVLNode x, AVLNode y, AVLNode z){
        NodeGroup g = getComponents(x,y,z);
        //Getting a NodeGroup object g that for x,y,z returns a,b,c node and subtrees t0,t1,t2 and t3
        g.b.left = g.a;
        g.b.right = g.c;

        g.a.left = g.t0;
        g.a.right = g.t1;

        g.c.left = g.t2;
        g.c.right = g.t3;

        if (z.parent != null) {
            if (z.parent.left == z) {
                z.parent.left = g.b;
            } else {
                z.parent.right = g.b;
            }
        } else {
            root = g.b;
        }
        g.b.parent = z.parent;

        g.a.parent = g.b;
        g.c.parent = g.b;



        updateHeights(g.a);
        updateHeights(g.c);
        updateHeights(g.b);
    } 

public void restructure(AVLNode x, AVLNode y, AVLNode z){
        NodeGroup g = getComponents(x,y,z);
        //Getting a NodeGroup object g that for x,y,z returns a,b,c node and subtrees t0,t1,t2 and t3
        g.b.left = g.a;
        g.b.right = g.c;

        g.a.left = g.t0;
        g.a.right = g.t1;

        g.c.left = g.t2;
        g.c.right = g.t3;

        if (z.parent != null) {
            if (z.parent.left == z) {
                z.parent.left = g.b;
            } else {
                z.parent.right = g.b;
            }
        } else {
            root = g.b;
        }
        g.b.parent = z.parent;

        g.a.parent = g.b;
        g.c.parent = g.b;



        updateHeights(g.a);
        updateHeights(g.c);
        updateHeights(g.b);
    } 

                        if(restructureNodeOnRemove.parent!=null){
                            updateHeights(restructureNodeOnRemove.parent);
                        } 

                        if(restructureNodeOnRemove.parent!=null){
                            updateHeights(restructureNodeOnRemove.parent);
                        } 

if (restructureNodeOnRemove != null) {
                        //update heights
                        updateHeights(restructureNodeOnRemove);
                        while (restructureNodeOnRemove != null) {
                            //restructure until tree is balanced
                            if (!isBalanced(restructureNodeOnRemove)) {
                                AVLNode z = restructureNodeOnRemove;
                                AVLNode y = (z.left != null && (z.right == null || z.left.height > z.right.height)) ? z.left : z.right;
                                AVLNode x = (y.left != null && (y.right == null || y.left.height > y.right.height)) ? y.left : y.right;
                                restructure(x, y, z);
                            }
                            restructureNodeOnRemove = restructureNodeOnRemove.parent;
                            if(restructureNodeOnRemove!=null){
                                updateHeights(restructureNodeOnRemove);
                            }
                        }

                    } 

if (restructureNodeOnRemove != null) {
                        //update heights
                        updateHeights(restructureNodeOnRemove);
                        while (restructureNodeOnRemove != null) {
                            //restructure until tree is balanced
                            if (!isBalanced(restructureNodeOnRemove)) {
                                AVLNode z = restructureNodeOnRemove;
                                AVLNode y = (z.left != null && (z.right == null || z.left.height > z.right.height)) ? z.left : z.right;
                                AVLNode x = (y.left != null && (y.right == null || y.left.height > y.right.height)) ? y.left : y.right;
                                restructure(x, y, z);
                            }
                            restructureNodeOnRemove = restructureNodeOnRemove.parent;
                            if(restructureNodeOnRemove!=null){
                                updateHeights(restructureNodeOnRemove);
                            }
                        }

                    } 

public class Main {
    public static void main(String[] args) {
        AVLTree tree = new AVLTree();

        // Insert nodes
        int[] nodesToInsert = {12,5,14,3,9,13,17,0,4,11,19};
        for (int key : nodesToInsert) {
            tree.insertNode(key, 0); // Using 0 as the value for simplicity
        }

        int[] nodesToRemove = {14};
        for (int key : nodesToRemove) {
            tree.removeNode(key); // Using 0 as the value for simplicity
        }


        // Display the tree
        StringBuilder treeDisplay = display(tree);
        System.out.println(treeDisplay);
    }

    public static StringBuilder display(AVLTree tree) {
        final int height = 5, width = 64;

        int len = width * height * 2 + 2;
        StringBuilder sb = new StringBuilder(len);

        for (int i = 1; i <= len; i++)
            sb.append(i < len - 2 && i % width == 0 ? "\n" : ' ');

        displayR(sb, width / 2, 1, width / 4, width, tree.getTreeRoot(), " ");
        return sb;
    }

    private static void displayR(StringBuilder sb, int c, int r, int d, int w, AVLNode n,
                                 String edge) {
        if (n != null) {
            if (n != n.left)
                displayR(sb, c - d, r + 2, d / 2, w, n.left, " /");

            String s = String.valueOf(n.key);
            int idx1 = r * w + c - (s.length() + 1) / 2;
            int idx2 = idx1 + s.length();
            int idx3 = idx1 - w;
            if (idx2 < sb.length())
                sb.replace(idx1, idx2, s).replace(idx3, idx3 + 2, edge);

            if (n != n.right)
                displayR(sb, c + d, r + 2, d / 2, w, n.right, "\\ ");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        AVLTree tree = new AVLTree();

        // Insert nodes
        int[] nodesToInsert = {12,5,14,3,9,13,17,0,4,11,19};
        for (int key : nodesToInsert) {
            tree.insertNode(key, 0); // Using 0 as the value for simplicity
        }

        int[] nodesToRemove = {14};
        for (int key : nodesToRemove) {
            tree.removeNode(key); // Using 0 as the value for simplicity
        }


        // Display the tree
        StringBuilder treeDisplay = display(tree);
        System.out.println(treeDisplay);
    }

    public static StringBuilder display(AVLTree tree) {
        final int height = 5, width = 64;

        int len = width * height * 2 + 2;
        StringBuilder sb = new StringBuilder(len);

        for (int i = 1; i <= len; i++)
            sb.append(i < len - 2 && i % width == 0 ? "\n" : ' ');

        displayR(sb, width / 2, 1, width / 4, width, tree.getTreeRoot(), " ");
        return sb;
    }

    private static void displayR(StringBuilder sb, int c, int r, int d, int w, AVLNode n,
                                 String edge) {
        if (n != null) {
            if (n != n.left)
                displayR(sb, c - d, r + 2, d / 2, w, n.left, " /");

            String s = String.valueOf(n.key);
            int idx1 = r * w + c - (s.length() + 1) / 2;
            int idx2 = idx1 + s.length();
            int idx3 = idx1 - w;
            if (idx2 < sb.length())
                sb.replace(idx1, idx2, s).replace(idx3, idx3 + 2, edge);

            if (n != n.right)
                displayR(sb, c + d, r + 2, d / 2, w, n.right, "\\ ");
        }
    }
}