手写二叉树遍历

public class TreeNode{
   public int data;
   public TreeNode leftChild;
   public TreeNode rightChild;
   public TreeNode(int data){
       this.data = data;
   }        
}
public class BinaryTree{
   TreeNode root;
   public void insertNode(int data){
         root =  insert(root,data);
   }
   public TreeNode insert(TreeNode node,int data){
        if(node ==  null){
            return TreeNode(data);
        } 
        if(data < node.data){ 
                node.leftChild = insert(node.leftChild,data);
        }  else if(data  > node.data){
                 node.rightChild = insert(node.rightChild,data);
        }else{
                 node.data =data;
        }
        return node;

   }
    public void preTraver(TreeNode node){
            if(node == null){
                 return;
            }
            System.out.println(node.data);
            preTraver(node.leftChild);
            preTraver(node.rightChild);
    }
    public void inTraver(TreeNode node){
             if(node == null){
                  return;
             }
             inTraver(node.leftChild);
             System.out.println(node.data);
             inTraver(node.rightChild);

    }
    public void postTraver(TreeNode node){
          if(node == null){
                  return;
          }
          postTraver(node.leftChild);
          postTraver(node.rightChild);
           System.out.println(node.data);
    }
    public void levelTraver(TreeNode node){
             if(node == null){
                  return;
              }
             Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(node)
             while(!queue.isEmpty()){
                    TreeNode item =  queue.poll();
                    System.out.println(item.data);
                    if(item.leftChild!=null){
                            queue.offer(item.leftChild);
                    }
                    if(item.rightChild){
                              queue.offer(item.rightChild);
                     }
             }
   }

}