树的遍历插入最小平衡子树

import javax.swing.tree.TreeNode;
import java.util.*;
import java.util.Queue;
import java.util.Stack;

public class BinaryTreeNode {
    public Tree construct(int[] preorder, int[] inorder){
        // 输入的合法性判断
        if (preorder == null || inorder == null || preorder.length != inorder.length || inorder.length < 1)
            return null;
        return construct(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
    }
    public Tree inOrderTraverse(Tree treeNode,int x){
        if (treeNode == null)
            return null;
        else if(treeNode.data<x)
            return inOrderTraverse(treeNode.rnode,x);
        else if(treeNode.data==x)
        {
            return treeNode;
        }
        else
            return inOrderTraverse(treeNode.lnode,x);
    }
    public void preOrder(Tree treeNode)
    {
        Stack<Tree> n=new Stack<>();
        Tree s=treeNode;
        while(s!=null||!n.empty())
        {
            if(s!=null)
            {
                n.push(s);
                System.out.println(n.peek().data);
                s=s.lnode;
            }
            else
            {
                s=n.peek();
                n.pop();
                s=s.rnode;
            }
        }
    }
    public int BSTdelete(Tree treeNode,int x)
    {
        Tree z;
        z=inOrderTraverse(treeNode, x);
        if(z.lnode==null&&z.rnode==null)
        {
            z=null;
            return  1;
        }
        else if(z.rnode!=null&&z.lnode==null)
        {
            z=z.rnode;
            return 1;
        }
        else if(z.rnode==null&&z.lnode!=null)
        {
            z=z.lnode;
            return 1;
        }
        else{
            return 0;
        }
    }
    public int  BSTinsert(Tree treeNode,int x)
    {
        if(treeNode==null)
        {
            treeNode.data=x;
            treeNode.lnode=null;
            treeNode.rnode=null;
            return 1;
        }
        else if(x==treeNode.data){
            return 0;
        }
        else if(x>treeNode.data)
        {
            if(treeNode.rnode==null)
            {
                treeNode.rnode=new Tree(x);
                return BSTinsert(treeNode.rnode,x);
            }
            else
                return BSTinsert(treeNode.rnode,x);
        }
        else
        {
            if(treeNode.lnode==null)
            {
                treeNode.lnode=new Tree(x);
                return BSTinsert(treeNode.lnode,x);
            }
            else
                return BSTinsert(treeNode.lnode,x);
        }
    }
    public void postOrder(Tree treeNode)
    {
        Stack<Tree> n=new Stack<>();
        Tree s=treeNode;
        Tree r=null;
        while(s!=null||!n.empty())
        {
            if(s!=null)
            {
                n.push(s);
                s=s.lnode;
            }
            else
            {
                s=n.peek();
                if(s.rnode!=null&&s.rnode!=r)
                {
                    s=s.rnode;
                }
                else {
                    n.pop();
                    System.out.println(s.data);
                    r=s;
                    s=null;
                }
            }
        }
    }
    public void inOrder(Tree treeNode)
    {
            Stack<Tree> n=new Stack<>();
            Tree s=treeNode;
            while(s!=null||!n.empty())
            {
                if(s!=null)
                {
                    n.push(s);
                    s=s.lnode;
                }
                else
                {
                    System.out.println(n.peek().data);
                    s=n.peek();
                    n.pop();
                    s=s.rnode;
                }
            }

     }
    public void Levelorder(Tree node){
        Queue<Tree> n=new LinkedList();
        if(node==null)
        {
            return;
        }
        Tree x;
        n.offer(node);
        while(!n.isEmpty())
        {
            x=n.element();
            System.out.println(x.data);
            n.poll();
            if(x.lnode!=null)
            {
                n.offer(x.lnode);
            }
            if(x.rnode!=null)
            {
                n.offer(x.rnode);
            }
        }
    }
    public Tree construct(int[] preorder, int ps, int pe, int[] inorder, int is, int ie){
        // 没有需要处理的元素了
        if (ps > pe || is > ie){
            return null;
        }
        // 取前序遍历的第一个数字当作为前的根结点
        int curRoot = preorder[ps];
        int index = is;
        // 在中序遍历的数组中找根结点的位置
        while (index <= ie && inorder[index] != curRoot)
            index++;
        // 如果在整个中序遍历的数组中没有找到，说明输入的参数是不合法的，抛出异常
        if (index > ie)
            throw new RuntimeException("非法输入");
        Tree node = new Tree(curRoot);
        node.data = curRoot;
        node.lnode = construct(preorder,ps+1,ps+index-is,inorder,is,index-1);
        node.rnode = construct(preorder,ps+1+index-is,pe,inorder,index+1,ie);
        // 返回当前的根节点
        return node;
    }
}