平衡二叉树的双旋转分析及实现

思路分析

当符合右旋转条件时：如果她的左子树的右子树高度大于右子树高度：

• 先对当前节点的左节点进行左旋转
• 再对当前节点进行右旋转

当符合左旋转条件时：如果它的右子树的左子树高度大于右子树：

• 先对当前节点的右节点进行右旋转
• 再对当前节点进行左旋转

package com.shujujiegou;



public class ran {

    public static void main(String[] args) {
//        int []arr={4,3,6,5,7,8};
        int []arr={10,12,8,9,7,6};
        erchapaixushu erchapaixushu=new erchapaixushu();

        //添加节点
        for(int i=0;i<arr.length;i++){
            erchapaixushu.add(new HeroNode(arr[i]));
        }

        erchapaixushu.zhongxu();

        System.out.println("在平衡处理后");
        System.out.println("树的高度="+erchapaixushu.getRoot().gaodu());
        System.out.println("树的左子树高度="+erchapaixushu.getRoot().zuo.gaodu());
        System.out.println("树的右子树高度="+erchapaixushu.getRoot().you.gaodu());

    }


}
//创建二叉排序树
class erchapaixushu{
    private HeroNode root;

    public HeroNode getRoot() {
        return root;
    }

    public HeroNode search(int value){
        if(root==null){
            return null;
        }else {
            return root.search(value);
        }
    }

    public HeroNode fujiedian(int value){
        if(root==null){
            return null;
        }else {
            return root.fujianjie(value);
        }
    }

    public int zuixiaozhi(HeroNode node){
        HeroNode temp=node;
        while (temp.zuo!=null){
            temp=temp.zuo;
        }
        shanchu(temp.value);
        return temp.value;
    }




    public void shanchu(int value){

        if(root==null){
            return;
        }else {
            HeroNode target=search(value);
            if(target==null){
                return;
            }
            if(root.zuo==null && root.you==null){
                root=null;
                return;
            }


            HeroNode baba=fujiedian(value);
            if(target.zuo==null && target.you==null){
                if(baba.zuo!=null && baba.zuo.value==value){
                    baba.zuo=null;
                }else if(baba.you!=null && baba.you.value==value){
                    baba.you=null;
                }
            }else if(target.zuo!=null && target.you!=null){
                int min=zuixiaozhi(target.you);
                target.value=min;
            }else {
                if(target.zuo!=null){
                    if(baba!=null){
                        if(baba.zuo.value==value){
                            baba.zuo=target.zuo;
                        }else {
                            baba.you=target.zuo;
                        }
                    }else {
                        root=target.zuo;
                    }

                }
                else {
                    if(baba!=null){
                        if(baba.you.value==value){
                            baba.you=target.you;
                        }else {
                            baba.zuo=target.you;
                        }
                    }else {
                        root=target.you;
                    }
                }
            }
        }
    }






    //添加节点的方法
    public void add(HeroNode heroNode){
        if(root==null){
            root=heroNode;
        }else {
            root.add(heroNode);
        }
    }

    //中序遍历
    public void zhongxu(){
        if (root!=null){
            root.zhongxu();
        }else {
            System.out.println("空");
        }
    }
}



class HeroNode{
    int value;
    HeroNode zuo;
    HeroNode you;

    public HeroNode(int value) {
        this.value = value;
    }


    @Override
    public String toString() {
        return "HeroNode{" +
                "value=" + value +
                '}';
    }

    //返回左子树的高度
    public int zuogaodu(){
        if(zuo==null){
            return 0;
        }
        return zuo.gaodu();
    }

    //返回右子树的高度
    public int yougaodu(){
        if(you==null){
            return 0;
        }
        return you.gaodu();
    }



    //返回以该节点为根节点的树的高度
    public int gaodu(){
        return Math.max(zuo==null? 0 : zuo.gaodu(),you==null? 0 :you.gaodu())+1;
    }


    public void zuoxuanzhuan(){
        //创建新的节点，以当前根节点的值
        HeroNode xin = new HeroNode(value);

        //把新的节点的左子树设置成当前节点的左子树
        xin.zuo=zuo;
        //吧新的节点的右子树设置成当前节点的右子树的左子树
        xin.you=you.zuo;
        //吧当前节点的值换成右子节点的值
        value=you.value;
        //吧当前节点的右子树设置成当前节点右子树的右子树
        you=you.you;
        //把当前节点的左子(左子节点)设置成创建的新节点
        zuo=xin;

    }

    private void youxuanzhuan(){
        HeroNode xin = new HeroNode(value);
        xin.you=you;
        xin.zuo=zuo.you;
        value=zuo.value;
        zuo=zuo.zuo;
        you=xin;
    }




    public HeroNode search(int value){
        if(value==this.value){
            //就是该节点
            return this;
        }else if(value<this.value){
            if(this.zuo==null){
                return null;
            }
            return this.zuo.search(value);
        }else {
            if(this.you==null){
                return null;
            }
            return this.you.search(value);
        }
    }





    public HeroNode fujianjie(int value){
        if( (this.zuo!=null && this.zuo.value==value) || (this.you!=null&&this.you.value==value)){
            return this;
        }else {
            //如果查找的值小于当前节点的值并且当前节点的左子节点不为空
            if(value<this.value && this.zuo!=null){
                return this.zuo.fujianjie(value);
            }else if(value>=this.value&& this.you!=null){
                return this.you.fujianjie(value);
            }else {
                return null;
            }
        }
    }





    //添加节点
    public void add(HeroNode node){
        //递归的形式添加节点，注意需要满足二叉排序树的要求
        if(node==null){
            return;
        }

        //传入的节点的值，和我们的当前的根节点的值的关系
        if(node.value<this.value){
            if(this.zuo==null){
                this.zuo=node;
            }else {
                this.zuo.add(node);
            }
        }

        if(node.value>=this.value){
            if(this.you==null){
                this.you=node;
            }else {
                this.you.add(node);
            }
        }
        //当添加玩一个节点的时候，如果右子树的高度-左子树的高度>1，就要左旋转
        if(yougaodu()-zuogaodu()>1){
            //如果它的右子树的左子树高度大于右子树高度
            if(you!=null && you.zuogaodu()>you.yougaodu()){
                //先对当前节点的右节点->右旋转
                you.youxuanzhuan();
                //再对当前节点进行左旋转
                zuoxuanzhuan();
            }else {
                //直接进行左旋转
                zuoxuanzhuan();
            }
            return; //必须要
        }

        //当添加完一个节点的时候，如果左子树的高度-右子树的高度>1，就要左旋转
        if(zuogaodu()-yougaodu()>1){
            //如果左子树高度大于右子树高度
            if(zuo!=null && zuo.yougaodu()>zuo.zuogaodu()){
                //先对当前节点的左节点（左子树）->左旋转
                zuo.zuoxuanzhuan();
                //再对当前节点进行右旋转
                youxuanzhuan();
            }else {
                //直接进行右旋转即可
                youxuanzhuan();
            }
        }
    }


    public void zhongxu(){
        if(this.zuo!=null){
            this.zuo.zhongxu();;
        }
        System.out.println(this);
        if(this.you!=null){
            this.you.zhongxu();
        }
    }


}

代码运行效果如下：