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

二叉树的一些属性：

int datdID;
double data;
TreeNode leftTree;
TreeNode rightTree;
TreeNode parent;

 

    //构建一个二叉树，将数据都放入了一个LIST里面
    int selfID = 0;
    public TreeNode creatTree(List<Double>datas,TreeNode tree){
        if(datas.size()!=0){
            TreeNode node = new TreeNode();
            node.setDatdID(selfID);
            node.setData(datas.get(0));

            //System.out.println(node.getData());
            node.setLeftTree(null);
            node.setRightTree(null);
            if(tree==null){
                datas.remove(0);
                tree = node;
            }else{

                TreeNode P = searchParent(node.getData(),tree);

                node.setParent(P);
                if(P.getData()>node.getData()){
                    P.setLeftTree(node);
                }else{
                    P.setRightTree(node);
                }
                datas.remove(0);
            }
            creatTree(datas,tree);
        }
        return tree;

    }

 

 

下列操作分别是查找节点的父节点以及4种遍历，其中要注意一下非递归方式去遍历

    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;

    }

//平衡二叉树的旋转

    //左旋变换
    public TreeNode SingleRotateWithLeft(TreeNode k2){
        TreeNode k1 = new TreeNode();
        k1 = k2.getLeftTree();
        k2.setLeftTree(k1.getRightTree());
        k1.setRightTree(k2);
        return k1;

    }

    //右旋变化换
    public TreeNode SingleRotateWithRight(TreeNode k2){
        TreeNode k1 = new TreeNode();
        k1 = k2.getRightTree();
        k2.setRightTree(k1.getLeftTree());
        k1.setLeftTree(k2);
        return k1;
    }

    //先进行一次右旋再进行一次左旋
    public TreeNode DoubleRotateWithLeft(TreeNode k3){
        k3.setLeftTree(SingleRotateWithRight(k3.getLeftTree()));
        return SingleRotateWithLeft(k3);
    }


    //先进行一次左旋再进行一次右旋
    public TreeNode DoubleRotateWithRight(TreeNode k3){
        k3.setRightTree(SingleRotateWithLeft(k3.getRightTree()));
        return SingleRotateWithRight(k3);
    }
//http://blog.csdn.net/a454042522/article/details/8591421          http://www.cppblog.com/cxiaojia/archive/2012/08/20/187776.html

//可以参考一下，