Java AVL Tree Insertion Issue: Incorrect Level Order Traversal

Question

Problem:

I'm currently working on implementing an AVL tree in Java as part of a data structures project. I've encountered an issue with the level order traversal of the tree after performing insertions. Despite several attempts at debugging, I haven't been able to pinpoint the problem.

AVL class

import java.util.LinkedList;
import java.util.Queue;

public class AVL{
    public BinaryNode root;
    public AVL(){
        this.root = null;
    }

    //preorder traversal
    public void preorder(BinaryNode node){
        if(node==null){
            return;
        }else{
            System.out.print(node.value+" ");
            preorder(node.left);
            preorder(node.right);
        }
    }

    //inorder traversal
    public void inorder(BinaryNode node){
        if(node==null){
            return;
        }else{
            inorder(node.left);
            System.out.print(node.value+" ");
            inorder(node.right);
        }
    }

    //postorder traversal
    public void postorder(BinaryNode node){
        if(node==null){
            return;
        }else{
            postorder(node.left);
            postorder(node.right);
            System.out.print(node.value+" ");
        }
    }

    //level order
    public void levelorder(){
        Queue<BinaryNode> queue = new LinkedList<BinaryNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            BinaryNode presNode = queue.remove();
            System.out.print(presNode.value+" ");
            if(presNode.left!= null){
                queue.add(presNode.left);
            }
            if(presNode.right != null){
                queue.add(presNode.right);
            }
        }
    }

    //search
    public BinaryNode search(BinaryNode node, int value){
        if(node== null){
            System.out.print("node not found");
            return null;
        }else if(node.value == value){
            System.out.print(value+" has been found");
            return node;
        }else if(node.left != null){
            return search(node.left, value);
        }else if(node.right != null){
            return search(node.right, value);
        }
        return node;
    }

    //search public
    public void search(int value){
        search(root, value);
    }

    //getheight
    public int getheight(BinaryNode node){
        if(node== null){
            return 0;
        }else{
            return node.height;
        }
    }

    //right spin
    public BinaryNode rightrotate(BinaryNode disbalNode){
        BinaryNode newNode = disbalNode.left;
        disbalNode.left = disbalNode.left.right;
        newNode.right = disbalNode;
        disbalNode.height = 1 + Math.max(getheight(disbalNode.left),getheight(disbalNode.right));
        newNode.height = 1 + Math.max(getheight(newNode.left),getheight(newNode.right));
        return newNode;
    }

    //left rotate
    public BinaryNode leftrotate(BinaryNode disbalNode){
        BinaryNode newNode = disbalNode.right;
        disbalNode.right = disbalNode.right.left;
        newNode.left = disbalNode;
        disbalNode.height = 1 + Math.max(getheight(disbalNode.left),getheight(disbalNode.right));
        newNode.height = 1 + Math.max(getheight(newNode.left),getheight(newNode.right));
        return newNode;
    }

    //getbalance
    public int getbalance(BinaryNode node){
        if(node == null){
            return 0;
        }else{
            return getheight(node.left) - getheight(node.right);
        }
    }

    //insert private
    private BinaryNode insert(BinaryNode node, int value){
        if(node==null){
            BinaryNode newNode = new BinaryNode();
            newNode.value = value;
            if(this.root == null){
                this.root = newNode;
            }
            newNode.height = 1;
            return newNode;
        }else if(value<node.value){
            node.left = insert(node.left, value);
        }else if(value>node.value){
            node.right = insert(node.right, value);
        }

        node.height = 1 + Math.max(getheight(node.left), getheight(node.right));
        int balance = getbalance(node);

        if(balance>1 && value<node.left.value){
            return rightrotate(node);
        }
        if(balance>1 && value>node.left.value){
            node.left = leftrotate(node.left);
            return rightrotate(node);
        }
        if(balance<-1 && value>node.right.value){
            return leftrotate(node);
        }
        if(balance<-1 && value<node.right.value){
            node.right = rightrotate(node.right);
            return leftrotate(node);
        }
        return node;
    }


    //insert public
    public void insert(int value){
        insert(root,value);
    }
}

Main class

class App{
    public static void main(String[] args) {

        AVL tree = new AVL();
        tree.insert(5);
        tree.insert(10);
        tree.insert(15);
        tree.insert(20);
        tree.levelorder();

    }
}

The issue appears to be related to the insert method in the AVL class. I suspect that I'm not correctly updating the root of the tree after inserting nodes, which is causing the incorrect level order traversal.

What I've Tried: I have reviewed my insert method and made changes to ensure that the tree's height and balance factors are updated correctly. However, I'm still not getting the expected output.

Expected Output vs. Actual Output: I expect the level order traversal to output "5 15 10 20" after inserting the values in the order mentioned. However, the actual output is different, and I can't figure out what's causing the discrepancy.

I'm looking for guidance on resolving this specific issue with the insert method and updating the root properly. Any help or insights would be greatly appreciated. Thank you!