二叉树的建立以及相关操作，平衡二叉树

    public TreeNode searchParent(double data,TreeNode tree){
        TreeNode P = new TreeNode();
        if(tree.getLeftTree()==null&&tree.getRightTree()==null){
            return tree;
        }else{
            if(data<tree.getData()){
                if(tree.getLeftTree()==null){
                    return tree;
                }else{
                    P=searchParent(data,tree.getLeftTree());
                }
            }else{
                if(tree.getRightTree()==null){

                    return tree;
                }else{
                    P=searchParent(data,tree.getRightTree());

                }
            }
            return P;
        }

    }


    //前序遍历(深度遍历)
    public void PreOrderTraversal(TreeNode tree){
        if(tree!=null){
            System.out.println(tree.getData());
            PreOrderTraversal(tree.getLeftTree());
            PreOrderTraversal(tree.getRightTree());
        }
    }

    //中序遍历
    public void MidOrderTraversal(TreeNode tree){
        if(tree!=null){
            MidOrderTraversal(tree.getLeftTree());
            System.out.println(tree.getData());
            MidOrderTraversal(tree.getRightTree());
        }
    }

    //后续遍历
    public void AftOrderTraversal(TreeNode tree){
        if(tree!=null){
            AftOrderTraversal(tree.getRightTree());
            System.out.println(tree.getData());
            AftOrderTraversal(tree.getLeftTree());
        }
    }


    //层次遍历(广度遍历)
    public void  LayerOrder(TreeNode root) { 
        System.out.println(root.getData());
        List<TreeNode>list = new ArrayList();
        list.add(root);
        int level = 1;
        int count = 0;
        while(!list.isEmpty()){
            List<TreeNode>childList = new ArrayList();
            while(!list.isEmpty()){
                childList.add(list.get(0));
                list.remove(0);
            }
            boolean flag = false;
            //宽度
            System.out.println("第"+count+++"层有节点  "+childList.size()+"个");
            for(int i = 0;i<childList.size();i++){
                if(childList.get(i).getLeftTree()!=null){
                    System.out.println(childList.get(i).getLeftTree().getData());
                    list.add(childList.get(i).getLeftTree());
                    flag = true;
                }
                if(childList.get(i).getRightTree()!=null){
                    System.out.println(childList.get(i).getRightTree().getData());
                    list.add(childList.get(i).getRightTree());
                    flag = true;
                }
            }
            if(flag){
                level++;
            }
        }
        //深度
        System.out.println("二叉树一共"+level+"层");

    }



    //非递归方法实现前序遍历
    public void preordernorec(TreeNode root){
        TreeNode pnode = root;
        Stack stack = new Stack();
        stack.push(root);
        while(!stack.isEmpty()){
            root = (TreeNode) stack.pop();
            System.out.println(root.getData());

            if(root.getRightTree()!=null){
                stack.push(root.getRightTree());
            }
            if(root.getLeftTree()!=null){
                stack.push(root.getLeftTree());
            }
        }

    }



    //交换二叉树的左右儿子，即二叉树的镜像
    public TreeNode exchange(TreeNode tree){
        if(tree==null){
            return tree;
        }else{
            //    System.out.println(tree.getData());
            TreeNode temp = tree.getLeftTree();
            tree.setLeftTree(tree.getRightTree());
            tree.setRightTree(temp);
            exchange(tree.getLeftTree());
            exchange(tree.getRightTree());
        }
        return tree;
    }


    //判断是否为完全二叉树
    public Boolean IsComplete(TreeNode tree){ 
        List<TreeNode>list = new ArrayList();
        list.add(tree);
        int level = lengthTree(tree);
        int count = 0;
        boolean flag = true;
        List<TreeNode> listresult = new ArrayList();
        while(level>2){
            List<TreeNode>childList = new ArrayList();
            while(!list.isEmpty()){
                childList.add(list.get(0));
                list.remove(0);
            }
            //宽度
            System.out.println("第"+count+++"层有节点  "+childList.size()+"个");
            for(int i = 0;i<childList.size();i++){
                if(childList.get(i).getLeftTree()!=null){
                    list.add(childList.get(i).getLeftTree());
                }else{

                    flag = false;
                }
                if(childList.get(i).getRightTree()!=null){
                    list.add(childList.get(i).getRightTree());
                }else{
                    flag = false;
                }
                if(flag == false){
                    break;
                }
            }
            listresult = childList;
            if(flag == false){
                break;
            }
            level = level-1;
        }
        int childLength = listresult.size();
        for(int i = 0;i<childLength;i++){

            if(listresult.get(i).getLeftTree()==null){
                flag =false;
            }

        }
        return flag;
    }


    //判断是否为平衡二叉树
    public Boolean IsBanlance(TreeNode tree){ 
        if(tree==null){
            return true;
        }else{
            if(tree.getLeftTree()!=null&&tree.getRightTree()!=null){
                int leftLength = lengthTree(tree.getLeftTree());
                int rightLength = lengthTree(tree.getRightTree());
                if(Math.abs(leftLength-rightLength)>1){
                    return false;
                }
            }else {
                if(tree.getLeftTree()!=null){
                    IsBanlance(tree.getLeftTree());
                }
                if(tree.getRightTree()!=null){
                    IsBanlance(tree.getRightTree());
                }
            }
        }
        return true;
    }



    //求树的深度
    public int  lengthTree(TreeNode root) { 
        List<TreeNode>list = new ArrayList();
        list.add(root);
        int level = 1;
        while(!list.isEmpty()){
            List<TreeNode>childList = new ArrayList();
            while(!list.isEmpty()){
                childList.add(list.get(0));
                list.remove(0);
            }
            boolean flag = false;
            for(int i = 0;i<childList.size();i++){
                if(childList.get(i).getLeftTree()!=null){
                    list.add(childList.get(i).getLeftTree());
                    flag = true;
                }
                if(childList.get(i).getRightTree()!=null){
                    list.add(childList.get(i).getRightTree());
                    flag = true;
                }
            }
            if(flag){
                level++;
            }
        }
        //深度
        return level;

    }