平衡二叉树的插入查找删除

Posted 鸟随二月

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了平衡二叉树的插入查找删除相关的知识,希望对你有一定的参考价值。

二叉平衡树的节点

package main.AVL;

public class AVLNode {
    private int value;
    private  int bf;
    private  AVLNode left;
    private  AVLNode right;
    private  AVLNode parent;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getBf() {
        return bf;
    }

    public void setBf(int bf) {
        this.bf = bf;
    }

    public AVLNode getLeft() {
        return left;
    }

    public void setLeft(AVLNode left) {
        this.left = left;
    }

    public AVLNode getRight() {
        return right;
    }

    public void setRight(AVLNode right) {
        this.right = right;
    }

    public AVLNode getParent() {
        return parent;
    }

    public void setParent(AVLNode parent) {
        this.parent = parent;
    }

    public AVLNode(int value, int bf, AVLNode left, AVLNode right, AVLNode parent) {
        this.value = value;
        this.bf = bf;
        this.left = left;
        this.right = right;
        this.parent = parent;
    }

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

小结

本人参考插入作品想继续写下删除的操作,又参考了该视频准备进行相应的编码,但在落笔前怎么也感觉删除操作与插入操作不同,感觉处理好子树的平衡后,父树不一定平衡,又参考了该作品,知道了失衡会传播,所以即使小编将子树失衡平衡好以后,还要进行父树平衡,进行节点中的平衡因子bf属性的修改,所以这里删除编码时小编偷了一个懒,,删除特定节点时,对平衡二叉树进行了重建

代码

package main.AVL;

public class AVLTree {
    private  AVLNode root;
    //右旋,针对失衡LL型
    public void rightRotate(AVLNode t){
        AVLNode left=t.getLeft();
        AVLNode parent=t.getParent();
        t.setLeft(left.getRight());
        if(left.getRight()!=null){
            left.getRight().setParent(t);
        }
        left.setRight(t);
        left.setParent(parent);
        t.setParent(left);
        if(parent==null){
            root=left;
        }else if (parent.getLeft()==t){
           parent.setLeft(left);
        }else{
            parent.setRight(left);}
        t.setBf(0);
        left.setBf(0);
    }
    //左旋RR型失衡
    public void leftRotate(AVLNode t){
        AVLNode right=t.getRight();
        AVLNode parent=t.getParent();
        t.setRight(right.getLeft());
        if (right.getLeft()!=null){
            right.getLeft().setParent(t);
        }
        right.setLeft(t);
        t.setParent(right);
        right.setParent(parent);
        if(parent==null){
            root=right;
        }else if(parent.getLeft()==t){
            parent.setLeft(right);
        }else{
            parent.setRight(right);
        }
        t.setBf(0);
        right.setBf(0);
    }
    //左右旋针对LR旋
    public void leftRightRotate(AVLNode t){
        AVLNode parent=t.getParent();
        AVLNode left=t.getLeft();
        AVLNode leftRight=left.getRight();

        left.setRight(leftRight.getLeft());
        if (leftRight.getLeft()!=null){
            leftRight.getLeft().setParent(left);
        }
        t.setLeft(leftRight.getRight());
        if (leftRight.getRight()!=null){
            leftRight.getRight().setParent(t);
        }

        leftRight.setLeft(left);
        left.setParent(leftRight);
        leftRight.setRight(t);
        t.setParent(leftRight);

        leftRight.setParent(parent);
        if (parent==null){
            root=leftRight;
        }else if(parent.getLeft()==t){
            parent.setLeft(leftRight);
        }else{
            parent.setRight(leftRight);
        }

        if (leftRight.getBf()==1){
            t.setBf(-1);
            left.setBf(0);
            leftRight.setBf(0);
        }else if (leftRight.getBf()==-1){
            t.setBf(0);
            left.setBf(1);
            leftRight.setBf(0);
        }else{
            t.setBf(0);
            left.setBf(0);
        }
    }
    //右左旋针对的是RL型失衡
    public  void rightLfetRotate(AVLNode t){
        AVLNode parent=t.getParent();
        AVLNode right=t.getRight();
        AVLNode rightLeft= right.getLeft();

        right.setLeft(rightLeft.getRight());
        if (rightLeft.getRight()!=null){
            rightLeft.getRight().setParent(right);
        }
        t.setRight(rightLeft.getLeft());
        if (rightLeft.getLeft()!=null){
            rightLeft.getLeft().setRight(t);
        }

        rightLeft.setLeft(t);
        t.setParent(rightLeft);
        rightLeft.setRight(right);
        right.setParent(rightLeft);

        rightLeft.setParent(parent);
        if (parent==null){
            root=rightLeft;
        }else if (parent.getLeft()==t){
            parent.setLeft(rightLeft);
        }else{
            parent.setRight(rightLeft);
        }
        if (rightLeft.getBf()==1){
            t.setBf(0);
            right.setBf(-1);
            rightLeft.setBf(0);
        }else if (rightLeft.getBf()==-1){
            t.setBf(1);
            right.setBf(0);
            rightLeft.setBf(0);
        }else{
            t.setBf(0);
            right.setBf(0);
        }
    }
    //插入节点
    public String insert(int i){
        AVLNode key=new AVLNode(i,0,null,null,null);
        //1.插入前是空树插入节点
        if (root==null){
            root=key;
            return "Success";
        }
        //2.插入前不是空树
        // 找位置
        AVLNode pre=null;
        AVLNode current=root;
        while(current!=null){
            pre=current;
            if (current.getValue()>i){
                current=current.getLeft();
            }else if (current.getValue()<i){
               current=current.getRight();
            }else
                return "Success";
        }
        //插入
        key.setParent(pre);
        if (pre.getValue()<i)
            pre.setRight(key);
        else
            pre.setLeft(key);

        //修改平衡因子并寻找最近的失衡节点
        current=key;

        while(pre!=null){
            if (pre.getLeft()==current){
                pre.setBf(pre.getBf()+1);
            }else{
                pre.setBf(pre.getBf()-1);
            }
            if (Math.abs(pre.getBf())>=2)
                break;
            current=pre;
            pre=pre.getParent();
        }
        if (pre==null)
            return "Success";
        if (pre.getBf()==2&&current.getBf()==1)
            this.rightRotate(pre);
        else if (pre.getBf()==2&&current.getBf()==-1)
            this.leftRightRotate(pre);
        else if(pre.getBf()==-2&&current.getBf()==1)
            this.rightLfetRotate(pre);
        else if (pre.getBf()==-2&&current.getBf()==-1)
            this.leftRotate(pre);
        return "Success";
    }
    //前序输入平衡二叉树;
    public void print(){
        this.print(root);
    }
    public void print( AVLNode current){
        if (current.getLeft()!=null){
            this.print(current.getLeft());
        }
        System.out.println(current);
        if (current.getRight()!=null){
            this.print(current.getRight());
        }
    }
    //查找某一点
    public AVLNode select(int k){
        return this.select(this.root,k);
    }
    public AVLNode select(AVLNode root,int k){
        AVLNode temp=null;
        if (root!=null){
            if (root.getValue()==k)
                temp=root;
            if (temp==null)
                temp=this.select(root.getLeft(),k);
            if (temp==null)
                temp=this.select(root.getRight(),k);
        }
        return temp;
    }
    //求树的高度
    public int height(AVLNode root){
        if (root==null)
            return 0;
        return Math.max(this.height(root.getLeft()),this.height(root.getRight()))+1;
    }

    //删除节点
    public String delete(int k){
        AVLNode current=this.select(k);
        //删除节点
        if (current==null)
            return "Success";
        if (current==this.root){
            this.root=null;
            return "Success";
        }
        AVLTree two=new AVLTree();
        this.againBuild(this.root,two,k);
        this.root=two.root;
        return "Success";
    }
    public void againBuild(AVLNode root,AVLTree two,int k){
        if (root!=null){
            againBuild(root.getLeft(),two,k);
            if (root.getValue()!=k)
                two.insert(root平衡二叉树的操作(高手进)

二叉树的深度平衡是啥意思?

平衡二叉树的删除

数据结构与算法查找(Search)详解

了解数据结构之平衡二叉树 (AVL)-插入和删除

AVL树(平衡二叉查找树)