I need help with this generics Java AVL tree program. So I have my AVL class java code below, there is something wrong with my insert, delete, and/or printing in traverse order methods because it does not print in order and it does not delete the inserts.

public class AVL> implements BalancedTree { private Node root; public AVL() { root = null; } // A utility function to get height of the tree public int height(Node N) { if (N == null) return 0; return N.height; } // A utility function to get maximum of two integers public int max(int a, int b) { return (a > b) ? a : b; } // A utility function to right rotate subtree rooted with y public Node rightRotate(Node y) { Node x = y.left; Node T2 = x.right; // Perform rotation x.right = y; y.left = T2; // Update heights y.height = max(height(y.left), height(y.right)) + 1; x.height = max(height(x.left), height(x.right)) + 1; // Return new root return x; } // A utility function to left rotate subtree rooted with x public Node leftRotate(Node x) { Node y = x.right; Node T2 = y.left; // Perform rotation y.left = x; x.right = T2; // Update heights x.height = max(height(x.left), height(x.right)) + 1; y.height = max(height(y.left), height(y.right)) + 1; // Return new root return y; } //Get Balance factor of node N public int getBalance(Node N) { if (N == null) return 0; return height(N.left) - height(N.right); } public Node insert(Node node, E item) { //1. Perform the normal BST rotation if (node == null) return (new Node(item)); if (node.item.compareTo(item) < 0) node.left = insert(node.left, item); else if (node.item.compareTo(item) > 0) node.right = insert(node.right, item); else // Equal keys not allowed return node; //2. Update height of this ancestor node node.height = 1 + max(height(node.left), height(node.right)); /* 3. Get the balance factor of this ancestor node to check whether this node became unbalanced */ int balance = getBalance(node); /*If this node becomes unbalanced, then there are 4 cases Left Left Case*/ if (balance > 1 && node.item.compareTo(node.left.item) < 0) return rightRotate(node); //Right Right Case if (balance < -1 && node.item.compareTo(node.right.item) > 0) return leftRotate(node); //Left Right Case if (balance > 1 && node.item.compareTo(node.left.item) > 0) { node.left = leftRotate(node.left); return rightRotate(node); } //Right Left Case if (balance < -1 && node.item.compareTo(node.right.item) < 0) { node.right = rightRotate(node.right); return leftRotate(node); } //return the (unchanged) node pointer return node; } /* Given a non-empty binary search tree, return the node with minimum key value found in that tree. Note that the entire tree does not need to be searched. */ public Node minValueNode(Node node) { Node current = node; //loop down to find the leftmost leaf while (current.left != null) current = current.left; return current; } public Node deleteNode(Node root, E item) { //Step 1: Perform standard BST delete if (root == null) return root; /*If the key to be deleted is smaller than the root's key, then it lies in left subtree*/ if (root.item.compareTo(root.item) < 0) root.left = deleteNode(root.left, item); /*If the key to be deleted is greater than the root's key, then it lies in right subtree*/ else if (root.item.compareTo(root.item) > 0) root.right = deleteNode(root.right, item); /*if key is same as root's key, then this is the node to be deleted*/ else { //node with only one child or no child if ((root.left == null) || (root.right == null)) { Node temp = null; if (temp == root.left) temp = root.right; else temp = root.left; //No child case if (temp == null) { temp = root; root = null; } else// One child case root = temp; // Copy the contents of // the non-empty child } else { /*node with two children: Get the inorder successor (smallest in the right subtree)*/ Node temp = minValueNode(root.right); //Copy the inorder successor's data to this node root.item = temp.item; //Delete the inorder successor root.right = deleteNode(root.right, temp.item); } } //If the tree had only one node then return if (root == null) return root; //Step 2: Update height of the current node root.height = max(height(root.left), height(root.right)) + 1; /*Step 3: Get the balance factor of this node (to check whether this node became unbalanced)*/ int balance = getBalance(root); //If this node becomes unbalanced, then there are 4 cases //Left Left Case if (balance > 1 && getBalance(root.left) >= 0) return rightRotate(root); //Left Right Case if (balance > 1 && getBalance(root.left) < 0) { root.left = leftRotate(root.left); return rightRotate(root); } //Right Right Case if (balance < -1 && getBalance(root.right) <= 0) return leftRotate(root); //Right Left Case if (balance < -1 && getBalance(root.right) > 0) { root.right = rightRotate(root.right); return leftRotate(root); } return root; } /*A utility function to print preorder traversal of the tree. The function also prints height of every node*/ public void inOrder(Node node) { if (node != null) { inOrder(node.left); System.out.print(node.item + " "); inOrder(node.right); } } public void insert(E item) { if(root==null) { root=new Node(item); } insert(root, item); } public E find(E item) { if (root==null){ root=new Node(item); } return search(root, item); } public void delete(E item) { deleteNode(root, item); } public void printInOrderTraversal() { inOrder(root); } public int isWellFormed() { return isBalanced(root); } public E search(Node node, E item) { //1.Perform the normal BST rotation //if (node.item.equalsIgnoreCase(key)) // return key; if (node == null) return null; if (node.item.compareTo(node.item) < 0) search(node.left, item); else if (node.item.compareTo(node.item) > 0) search(node.right, item); return null; } public int isBalanced(Node node) { int lh; //for height of left subtree int rh; //for height of right subtree //If tree is empty then return true if (node == null) return 1; //Get the height of left and right sub trees lh = height(node.left); rh = height(node.right); if (Math.abs(lh - rh) <= 1 && isBalanced(node.left) == 1 && isBalanced(node.right) == 1) return 1; //If we reach here then tree is not height-balanced return 0; } }