平衡二叉树（AVL树）

最新推荐文章于 2021-11-26 11:47:00 发布
最新推荐文章于 2021-11-26 11:47:00 发布
阅读量407 收藏 1
点赞数
文章标签： linux 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46635575/article/details/121443963
版权

本文重点在将平衡二叉树的概念和代码实现

二叉树的系列文章：

一、平衡二叉树（AVL树）

看一个案例（说明二叉树可能的问题）

  • 给你一个数列{1,2，3,4，5,6}，要求创建一颗二叉排序树（BST），分析问题所在。

在这里插入图片描述

1、平衡二叉树

首先这个平衡二叉树是在二叉排序树的基础上完成的。
在这里插入图片描述

2、什么是旋转

（1）选择的分类

1、旋转分如下

  • 单旋转
    • 左
    • 右
  • 双旋转

2、先来看左旋转。

  • 什么是左旋转呢？不太好说得出来。
    • 就是单选转是左旋转或者右旋转
    • 就是假设我们的右子树的高度高于左子树的之后，进行左旋转，得到一颗平衡二叉树
    • 它的概念是：对节点A的左旋转（1、将A节点的右节点的左节点，指向A节点。2、将节点的右节点，指向A节点的右节点的左节点）
    • 什么时候用到左旋转呢？就是右子树的高度大于左子树的时候
  • 看下面的一个例子：
    在这里插入图片描述
    得到的一颗树就是这个样子的一颗树
    在这里插入图片描述

（2）什么时候要旋转呢？

1、首先来看一下再看文章的你是否看过这篇文章

2、什么时候用？

其实说白点就是要计算一下我们树的高度，否则计算机无法判断是否要进行选择。

3、看实现计算方法的代码

  • 看Node类的如下方法
    • 方法五
    • 方法六
    • 方法七
    • 其他的就是从之前文章里面复制过来的
    • 最后来看测试的实现
package cn.mldn.AVL;

public class AVLTreeDemo {
    public static void main(String[] args) {
        int[] arr = {4,3,6,7,8};
        AVLTree avlTree = new AVLTree();
        for (int i = 0; i < arr.length; i++) {
            avlTree.add(new Node(arr[i]));
        }

        //中序遍历一下
        avlTree.infixOrder();

        //在没有进行平衡处理之前康康树的高度
        System.out.println("未处理之前");
        System.out.println(avlTree.getRoot().height());//未处理之前 4
        System.out.println("树左子树高度 = " + avlTree.getRoot().leftHeight());//树左子树高度 = 1
        System.out.println("树右子树高度 = " + avlTree.getRoot().rightHeight());//树右子树高度 = 3

    }
}

//第二步来看这个类
class AVLTree {
    private Node root;//根节点

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    //方法一：添加的方法
    public void add(Node node) {
        if (root == null) {
            this.root = node;
        } else {
            root.add(node);
        }
    }

    //方法二：中序遍历的方法
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序树为空");
        }
    }

    //方法三：查找要删除的节点
    public Node search(int value) {
        if (root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }

    //方法四：查找父节点
    public Node searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }


    //方法五：真正的删除方法
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            //1、需要先去找到要删除的节点 ，targetNode
            Node targetNode = search(value);
            //如果没有找到删除的节点
            if (targetNode == null) {
                return;//直接没什么必要执行下面的代码了
            }
            //如果发现当前二叉树只有最后一个节点（根节点）的情况下
            if (root.left == null && root.right == null) {
                //直接把root制空
                root = null;
                return;
            }
            //2、去找到targetNode的父节点
            Node parent = searchParent(value);
            //3、如果要删除的节点
            // 3.1是叶子节点
            if (targetNode.left == null && targetNode.right == null) {
                //说明是叶子节点
                //如果是父节点的左子节点，还是右子节点
                //如果是左子节点
                if (parent.left != null && parent.left.value == value) {
                    parent.left = null;
                }//如果是右子节点。
                else if (parent.right != null && parent.right.value == value) {
                    parent.right = null;
                }
            } else if (targetNode.left != null && targetNode.right != null) {
                //3.2如果要删除的节点是左右子树都有的情况下
                //先去编写delRightTreeMin方法来辅助完成，找到最小值【其实这个方法的思路也可以是去从左子树去找最大的】
                int minValue = delRightTreeMin(targetNode.right);
                targetNode.value = minValue;
            } else {
                //3.3 除了是叶子节点和除了左右节点都有值的情况，其他的就是只有一遍的子节点的情况了撒
                //如果要删除的节点是有左子节点的情况
                if (targetNode.left != null) {
                    if (parent != null) {
                        //如果要删除的节点是父节点的左子节点的情况下
                        if (parent.left.value == value) {//说明targetNode是父节点的左子节点
                            parent.left = targetNode.left;//直接把待删除节点的左子节点拼接的到父节点的左子节点行
                        } else {//如果targetNode是parent的右子节点
                            parent.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;//具体为什么这里这样写，你可以自己画图分析一下。
                    }
                }
                //如果要删除的节点是有右子节点的情况下
                else {
                    if (parent != null) {
                        //如果要删除的节点是父节点的左子节点的情况下
                        if (parent.left.value == value) {//说明targetNode是父节点的左子节点
                            parent.left = targetNode.right;//直接把待删除节点的左子节点拼接的到父节点的左子节点行
                        } else {//如果targetNode是parent的右子节点
                            parent.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;//具体为什么这里这样写，你可以自己画图分析一下。
                    }
                }
            }
        }
    }

    /**
     * 编写零时的方法一个方法，要有如下作用
     *      1、返回node为根节点的二叉排序树的最小节点的值
     *      2、删除以node为根节点的二叉排序树的最小节点
     * @param node 当做一颗二叉排序树的根节点
     * @return 返回的是以node为根节点的二叉排序树的最小节点值
     */
    public int delRightTreeMin(Node node) {
        Node target = node;
        //从以node为根节点的树循环的往左找，就会找到最小值
        while (target.left != null) {
            target = target.left;
        }
        //这时target就指向了最小节点
        //删除最小节点
        delNode(target.value);
        //然后返回节点对应的值
        return target.value;
    }
}




//第一步看这个节点类
class Node {
    int value;//值信息
    Node left;//左子节点
    Node right;//右子节点

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


    /**
     * 方法五
     * 这个方法用来计算树的高度的方法，具体来看
     * @return 以当前节点为根节点的树的高度
     */
    public int height() {
        //left == null ? 0 : left.height()这个是什么意思，如果left为空，则返回0，不为空则向下递归的去调用这个方法进行计算
        //  为什么最后又加了 1 呢？因为这个根节点本身也是会是一层高度
        return Math.max(left == null ? 0 : left.height(),right == null ? 0 : right.height()) + 1;
    }

    /**
     * 方法六
     * 返回左子树的高度
     * @returen
     */
    public int leftHeight() {
        if (left == null) {
            return 0;
        }
        return left.height();
    }

    /**
     * 方法七
     * 返回右子树的高度
     * @return
     */
    public int rightHeight() {
        if (right == null) {
            return 0;
        }
        return right.height();
    }


    //方法一：添加节点的方法
    //递归形式添加，需要满足二叉排序树的要求
    public void add(Node node) {
        if (node == null) {
            return;
        }
        //判断传入节点的值，是否和我们当前子树与根节点的关系
        if (node.value < this.value) {//this等价于我们当前子树
            if (this.left == null) {
                this.left = node;
            } else {//如果左边不为空
                this.left.add(node);//递归的当前节点的左子树添加
            }
        } else {//如果添加的值大于当前节点的值
            //如果右边是为空
            if (this.right == null) {
                this.right = node;
            } else {//右子树不为空的话，也是递归添加
                this.right.add(node);
            }
        }
    }

    //方法二：中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this.toString());
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

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




    /**
     * //方法三：用来查找我们要删除的数据
     * @param value 你希望找的值
     * @return 找到则返回，找不到则返回null
     */
    public Node search(int value) {
        //为什么不上来就判断是否为空呢？
        if (value == this.value) {//说明找到
            return this;
        } else if (value < this.value) {//如果查找的值，小于当前节点的值，应该向左递归查号
            //如果左子节点为空的话就不能找了
            if (this.left == null) {
                return null;
            }
            return this.left.search(value);
        } else {//不小于的话就是大于等于了
            if (this.right == null) {
                return null;
            }
            return this.right.search(value);
        }
    }

    /**
     * 方法四：是我们要查找节点的父节点
     *      因为经过我们思路分析中：要找到它的父节点才能删除
     * @param value，待查找的值
     * @return 返回的是父节点
     */
    public Node searchParent(int value) {
        if ((this.left != null && this.left.value == value)
                || (this.right != null && this.right.value == value)) {
            //说明我们找到了，我们要删除的节点的父节点的值，我们要进行的是和父节点的左右子节点进行比较，判断是否找到
            return this;
        } else {
            //如果查找的值不是的情况下
            //如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
            if (value < this.value && this.left != null) {
                //想左子树递归查找
                return this.left.searchParent(value);
            } else if (value >= value && this.right != null) {
                //向右子树进行递归查找
                return this.right.searchParent(value);
            } else {//说明没有父节点
                //没有找到父节点，比如根节点是没有父节点的
                return null;
            }
        }
    }
}

（3）左旋转的代码实现

去看如下方法

  • 我们节点类的：方法八对添加的时候进行左旋转处理
  • 最后再去看我节点类的add方法，在最后一行添加了判断条件
package cn.mldn.AVL;

public class AVLTreeDemo {
    public static void main(String[] args) {
        int[] arr = {4,3,6,7,8};
        AVLTree avlTree = new AVLTree();
        for (int i = 0; i < arr.length; i++) {
            avlTree.add(new Node(arr[i]));
        }

        //中序遍历一下
        avlTree.infixOrder();

        //在没有进行平衡处理之前康康树的高度
        System.out.println("未处理之前");
        System.out.println(avlTree.getRoot().height());//未处理之前 4
        System.out.println("树左子树高度 = " + avlTree.getRoot().leftHeight());//树左子树高度 = 1
        System.out.println("树右子树高度 = " + avlTree.getRoot().rightHeight());//树右子树高度 = 3





    }
}

//第二步来看这个类
class AVLTree {
    private Node root;//根节点

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    //方法一：添加的方法
    public void add(Node node) {
        if (root == null) {
            this.root = node;
        } else {
            root.add(node);
        }
    }

    //方法二：中序遍历的方法
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序树为空");
        }
    }

    //方法三：查找要删除的节点
    public Node search(int value) {
        if (root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }

    //方法四：查找父节点
    public Node searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }


    //方法五：真正的删除方法
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            //1、需要先去找到要删除的节点 ，targetNode
            Node targetNode = search(value);
            //如果没有找到删除的节点
            if (targetNode == null) {
                return;//直接没什么必要执行下面的代码了
            }
            //如果发现当前二叉树只有最后一个节点（根节点）的情况下
            if (root.left == null && root.right == null) {
                //直接把root制空
                root = null;
                return;
            }
            //2、去找到targetNode的父节点
            Node parent = searchParent(value);
            //3、如果要删除的节点
            // 3.1是叶子节点
            if (targetNode.left == null && targetNode.right == null) {
                //说明是叶子节点
                //如果是父节点的左子节点，还是右子节点
                //如果是左子节点
                if (parent.left != null && parent.left.value == value) {
                    parent.left = null;
                }//如果是右子节点。
                else if (parent.right != null && parent.right.value == value) {
                    parent.right = null;
                }
            } else if (targetNode.left != null && targetNode.right != null) {
                //3.2如果要删除的节点是左右子树都有的情况下
                //先去编写delRightTreeMin方法来辅助完成，找到最小值【其实这个方法的思路也可以是去从左子树去找最大的】
                int minValue = delRightTreeMin(targetNode.right);
                targetNode.value = minValue;
            } else {
                //3.3 除了是叶子节点和除了左右节点都有值的情况，其他的就是只有一遍的子节点的情况了撒
                //如果要删除的节点是有左子节点的情况
                if (targetNode.left != null) {
                    if (parent != null) {
                        //如果要删除的节点是父节点的左子节点的情况下
                        if (parent.left.value == value) {//说明targetNode是父节点的左子节点
                            parent.left = targetNode.left;//直接把待删除节点的左子节点拼接的到父节点的左子节点行
                        } else {//如果targetNode是parent的右子节点
                            parent.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;//具体为什么这里这样写，你可以自己画图分析一下。
                    }
                }
                //如果要删除的节点是有右子节点的情况下
                else {
                    if (parent != null) {
                        //如果要删除的节点是父节点的左子节点的情况下
                        if (parent.left.value == value) {//说明targetNode是父节点的左子节点
                            parent.left = targetNode.right;//直接把待删除节点的左子节点拼接的到父节点的左子节点行
                        } else {//如果targetNode是parent的右子节点
                            parent.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;//具体为什么这里这样写，你可以自己画图分析一下。
                    }
                }
            }
        }
    }

    /**
     * 编写零时的方法一个方法，要有如下作用
     *      1、返回node为根节点的二叉排序树的最小节点的值
     *      2、删除以node为根节点的二叉排序树的最小节点
     * @param node 当做一颗二叉排序树的根节点
     * @return 返回的是以node为根节点的二叉排序树的最小节点值
     */
    public int delRightTreeMin(Node node) {
        Node target = node;
        //从以node为根节点的树循环的往左找，就会找到最小值
        while (target.left != null) {
            target = target.left;
        }
        //这时target就指向了最小节点
        //删除最小节点
        delNode(target.value);
        //然后返回节点对应的值
        return target.value;
    }
}




//第一步看这个节点类
class Node {
    int value;//值信息
    Node left;//左子节点
    Node right;//右子节点

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


    /**
     * 方法五
     * 这个方法用来计算树的高度的方法，具体来看
     * @return 以当前节点为根节点的树的高度
     */
    public int height() {
        //left == null ? 0 : left.height()这个是什么意思，如果left为空，则返回0，不为空则向下递归的去调用这个方法进行计算
        //  为什么最后又加了 1 呢？因为这个根节点本身也是会是一层高度
        return Math.max(left == null ? 0 : left.height(),right == null ? 0 : right.height()) + 1;
    }

    /**
     * 方法六
     * 返回左子树的高度
     * @returen
     */
    public int leftHeight() {
        if (left == null) {
            return 0;
        }
        return left.height();
    }

    /**
     * 方法七
     * 返回右子树的高度
     * @return
     */
    public int rightHeight() {
        if (right == null) {
            return 0;
        }
        return right.height();
    }


    /**
     * 方法八
     * 对树进行左旋转的方法
     */
    public void leftRotate() {
        //1、创建新节点，以当前根节点的值进行创建
        Node newNode = new Node(value);
        //2、把新的节点左子树设置成当前节点的左子树
        newNode.left = left;
        //3、把新的节点的右子树设为当前节点的右子树的左子树
        newNode.right = right.left;
        //4、当前节点的值换成右子节点的值
        value = right.value;
        //5、把当前节点的右子树设置成当前节点右子树的右子树
        right = right.right;
        //6、把当前节点的左子节点设置为新的节点
        left = newNode;
    }


    //方法一：添加节点的方法
    //递归形式添加，需要满足二叉排序树的要求
    public void add(Node node) {
        if (node == null) {
            return;
        }
        //判断传入节点的值，是否和我们当前子树与根节点的关系
        if (node.value < this.value) {//this等价于我们当前子树
            if (this.left == null) {
                this.left = node;
            } else {//如果左边不为空
                this.left.add(node);//递归的当前节点的左子树添加
            }
        } else {//如果添加的值大于当前节点的值
            //如果右边是为空
            if (this.right == null) {
                this.right = node;
            } else {//右子树不为空的话，也是递归添加
                this.right.add(node);
            }
        }

        //当添加完一个节点后，如果右子树高度 - 左子树的高度 > 1,这时候要左旋转
        if (rightHeight() - leftHeight() > 1) {
            leftRotate();
        }
    }

    //方法二：中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this.toString());
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

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




    /**
     * //方法三：用来查找我们要删除的数据
     * @param value 你希望找的值
     * @return 找到则返回，找不到则返回null
     */
    public Node search(int value) {
        //为什么不上来就判断是否为空呢？
        if (value == this.value) {//说明找到
            return this;
        } else if (value < this.value) {//如果查找的值，小于当前节点的值，应该向左递归查号
            //如果左子节点为空的话就不能找了
            if (this.left == null) {
                return null;
            }
            return this.left.search(value);
        } else {//不小于的话就是大于等于了
            if (this.right == null) {
                return null;
            }
            return this.right.search(value);
        }
    }

    /**
     * 方法四：是我们要查找节点的父节点
     *      因为经过我们思路分析中：要找到它的父节点才能删除
     * @param value，待查找的值
     * @return 返回的是父节点
     */
    public Node searchParent(int value) {
        if ((this.left != null && this.left.value == value)
                || (this.right != null && this.right.value == value)) {
            //说明我们找到了，我们要删除的节点的父节点的值，我们要进行的是和父节点的左右子节点进行比较，判断是否找到
            return this;
        } else {
            //如果查找的值不是的情况下
            //如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
            if (value < this.value && this.left != null) {
                //想左子树递归查找
                return this.left.searchParent(value);
            } else if (value >= value && this.right != null) {
                //向右子树进行递归查找
                return this.right.searchParent(value);
            } else {//说明没有父节点
                //没有找到父节点，比如根节点是没有父节点的
                return null;
            }
        }
    }
}

（4）向右旋转

  • 问题自然不用描述，是左子树的高度大于我们的右子树的高度，这时候要进行右旋转。
  • 思路实现如下

在这里插入图片描述

  • 最终得到如下的一个树
    在这里插入图片描述

（5）向右旋转的代码实现

阅读顺序如下

  • 首先去阅读我们的方法九，对树进行右旋转
  • 最后同样的去看添加方法
  • 其他的可以自己测试一下
//第一步看这个节点类
class Node {
    int value;//值信息
    Node left;//左子节点
    Node right;//右子节点

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


    /**
     * 方法五
     * 这个方法用来计算树的高度的方法，具体来看
     * @return 以当前节点为根节点的树的高度
     */
    public int height() {
        //left == null ? 0 : left.height()这个是什么意思，如果left为空，则返回0，不为空则向下递归的去调用这个方法进行计算
        //  为什么最后又加了 1 呢？因为这个根节点本身也是会是一层高度
        return Math.max(left == null ? 0 : left.height(),right == null ? 0 : right.height()) + 1;
    }

    /**
     * 方法六
     * 返回左子树的高度
     * @returen
     */
    public int leftHeight() {
        if (left == null) {
            return 0;
        }
        return left.height();
    }

    /**
     * 方法七
     * 返回右子树的高度
     * @return
     */
    public int rightHeight() {
        if (right == null) {
            return 0;
        }
        return right.height();
    }


    /**
     * 方法八
     * 对树进行左旋转的方法
     */
    public void leftRotate() {
        //1、创建新节点，以当前根节点的值进行创建
        Node newNode = new Node(value);
        //2、把新的节点左子树设置成当前节点的左子树
        newNode.left = left;
        //3、把新的节点的右子树设为当前节点的右子树的左子树
        newNode.right = right.left;
        //4、当前节点的值换成右子节点的值
        value = right.value;
        //5、把当前节点的右子树设置成当前节点右子树的右子树
        right = right.right;
        //6、把当前节点的左子节点设置为新的节点
        left = newNode;
    }


    /**
     * 方法九
     * 对树进行右旋转
     */
    public void rightRotate() {
        Node newNode = new Node(value);
        newNode.right = right;
        newNode.left = left.right;
        value = left.value;
        left = left.left;
        right = newNode;
    }

    //方法一：添加节点的方法
    //递归形式添加，需要满足二叉排序树的要求
    public void add(Node node) {
        if (node == null) {
            return;
        }
        //判断传入节点的值，是否和我们当前子树与根节点的关系
        if (node.value < this.value) {//this等价于我们当前子树
            if (this.left == null) {
                this.left = node;
            } else {//如果左边不为空
                this.left.add(node);//递归的当前节点的左子树添加
            }
        } else {//如果添加的值大于当前节点的值
            //如果右边是为空
            if (this.right == null) {
                this.right = node;
            } else {//右子树不为空的话，也是递归添加
                this.right.add(node);
            }
        }

        //当添加完一个节点后，如果右子树高度 - 左子树的高度 > 1,这时候要左旋转
        if (rightHeight() - leftHeight() > 1) {
            leftRotate();
        }
        //当添加完后，如果左子树高度 - 右子树高度 > 1，则由旋转
        if (leftHeight() - rightHeight() > 1) {
            rightRotate();
        }
    }

    //方法二：中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this.toString());
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

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




    /**
     * //方法三：用来查找我们要删除的数据
     * @param value 你希望找的值
     * @return 找到则返回，找不到则返回null
     */
    public Node search(int value) {
        //为什么不上来就判断是否为空呢？
        if (value == this.value) {//说明找到
            return this;
        } else if (value < this.value) {//如果查找的值，小于当前节点的值，应该向左递归查号
            //如果左子节点为空的话就不能找了
            if (this.left == null) {
                return null;
            }
            return this.left.search(value);
        } else {//不小于的话就是大于等于了
            if (this.right == null) {
                return null;
            }
            return this.right.search(value);
        }
    }

    /**
     * 方法四：是我们要查找节点的父节点
     *      因为经过我们思路分析中：要找到它的父节点才能删除
     * @param value，待查找的值
     * @return 返回的是父节点
     */
    public Node searchParent(int value) {
        if ((this.left != null && this.left.value == value)
                || (this.right != null && this.right.value == value)) {
            //说明我们找到了，我们要删除的节点的父节点的值，我们要进行的是和父节点的左右子节点进行比较，判断是否找到
            return this;
        } else {
            //如果查找的值不是的情况下
            //如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
            if (value < this.value && this.left != null) {
                //想左子树递归查找
                return this.left.searchParent(value);
            } else if (value >= value && this.right != null) {
                //向右子树进行递归查找
                return this.right.searchParent(value);
            } else {//说明没有父节点
                //没有找到父节点，比如根节点是没有父节点的
                return null;
            }
        }
    }
}

（6）双旋转

1、问题来源

  • 之前的代码中，我们进行单旋转就可以得到一个AVLTree了，但是有些情况是得到进行单旋转是得不到解决的
  • 康康这个情况

在这里插入图片描述

2、分析原因和解决

（1）分析原因

  • 因为当我们进行编写代码的时候旋转过来，就相当于镜相一样，把它对称一样。这样反而不行，导致之前的左子树高，右子树高度低，转向右子树高，左子树低的情况。

（2）解决办法

  • 当符号右旋转的条件时

    • 如果它的左子树的右子树高度大于左子树高度时

      • 要先对当前这个节点左节点进行左旋转

      • 得到这样的一个结果
        在这里插入图片描述

      • 然后对上面的进行处理过后的树，以当前节点进行向右旋转即可
        在这里插入图片描述

  • 同样的当符合左旋转的情况时候

    • 如果它的右子树的左子树的高度大于它的右子树的高度，进行选择
      • 先要此子树进行右旋转
      • 然后再进行左旋转即可

（7）双旋转的代码实现

其他的不变，只有这个方法改变

//方法一：添加节点的方法
    //递归形式添加，需要满足二叉排序树的要求
    public void add(Node node) {
        if (node == null) {
            return;
        }
        //判断传入节点的值，是否和我们当前子树与根节点的关系
        if (node.value < this.value) {//this等价于我们当前子树
            if (this.left == null) {
                this.left = node;
            } else {//如果左边不为空
                this.left.add(node);//递归的当前节点的左子树添加
            }
        } else {//如果添加的值大于当前节点的值
            //如果右边是为空
            if (this.right == null) {
                this.right = node;
            } else {//右子树不为空的话，也是递归添加
                this.right.add(node);
            }
        }

        //当添加完一个节点后，如果右子树高度 - 左子树的高度 > 1,这时候要左旋转
        if (rightHeight() - leftHeight() > 1) {
            //1、如果它的右子树的左子树的高度大于它的右子树的高度，进行选择
            if (right != null && right.leftHeight() > right.rightHeight()) {
                //首先对子树进行选择
                right.rightRotate();
                //然后对它自己进行选择
                leftRotate();
            } else {
                //说明不满足情况，直接选择
                leftRotate();
            }
            return;//因为我们是每添加一个就进行处理，所以在这里直接进行返回，不然可能出问题的
        }
        //当添加完后，如果左子树高度 - 右子树高度 > 1，则由旋转
        if (leftHeight() - rightHeight() > 1) {
            //1、如果它的左子树的右子树高度大于它的左子树的高度时，
            if (left != null && left.rightHeight() > left.leftHeight()) {
                //先对左子树进行左旋转
                left.leftRotate();
                //然后对它自己进行选择
                rightRotate();
            } else {
                //说明可以直接进行选择
                rightRotate();
            }
            return;//因为我们是每添加一个就进行处理，所以在这里直接进行返回
        }
    }

3、平衡二叉树的小结

解释了我们可能存在问题，然后引入了平衡二叉树，然后以我们就此解决办法，得到最后的一个结果。

  • 重点如下
    • 对它平衡之前必须是一个二叉排序树
    • 上面代码一定要加以练习，如果愿意，可以使用泛型来实现一波。
同学郑学习
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
平衡二叉树(AVL)
Zllvincent的博客
06-04 715
一.简介 AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。 二.实现 三.总结 ...
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有以下性质： * 每个节点的左...
平衡二叉树
Gunther的博客
12-06 116
1.利用之前的二叉树的深度，但是这样就会导致重复遍历子树 牛客网通过code： class Solution { public: int TreeDepth(TreeNode* pRoot) { if (pRoot == nullptr)return 0; return TreeDepth(pRoot-&amp;gt;left) &amp;gt; TreeDepth(pRoot-&amp;gt;right) ...
平衡二叉树关键代码
ENAIC__suger的博客
05-11 327
struct AVLNode; typedef struct AVLNode *PAVLNode; struct AVLNode { KeyType key; int bf; PAVLNode llink,rlink; }; typedef struct AVLNode *AVLTree; typedef struct *PAVLTree; int avlInsert(PAVLT...
AVL树单选转和双旋转
luluLUOYIS
04-02 798
看了好几天树了，也算有点心得。学树，必须要图。这里有两篇里的博客，在结合书，我用的是《数据结构与算法分析C++版》就可以了。 http://blog.csdn.net/a454042522/article/details/8591421 http://blog.csdn.net/vesper305/article/details/13614403 在AVL树中必须平衡的点叫做
java数据结构与算法之平衡二叉树AVL树的设计与实现分析.doc
11-17
java数据结构与算法之平衡二叉树AVL树的设计与实现分析.doc
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
最新发布
02-10
平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
平衡二叉树-AVL树的实现
12-10
平衡二叉树是一种特殊的二叉树结构，其中每个节点的两个子树的高度差不超过1，以确保树的平衡，从而优化查找、插入和删除等操作的时间复杂度。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. ...
平衡二叉树（AVL树）浅析
10-20
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，它的主要特性是任何节点的两个子树的高度最大相差1，这确保了在AVL树中的查找、插入和删除操作的时间复杂度都能保持在O(log n)。在本笔记中，我们将深入探讨AVL树的...
AVLtree_c_avl_平衡二叉树_avltree_
10-02
综上所述，"AVLtree_c_avl_平衡二叉树_avltree_"这个项目可能是用C语言实现了一个AVL树的数据结构，并提供了对树的增删改查操作，同时具备用户友好的交互界面。这个项目对于理解和实践AVL树的概念、操作和性能优化...
平衡二叉树 AVL
04-30
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是其左右子树的高度差不超过1，从而确保了搜索、插入和删除等操作的...
平衡二叉树(AVL树).docx
12-07
平衡二叉树（AVL树）是数据结构领域中一种重要的自平衡二叉搜索树，由Adelson-Velskii和Landis于1962年提出。这种数据结构的主要特性在于，它确保了任何节点的两个子树高度差不超过1，从而在保持二叉搜索树性质的...
平衡二叉树(AVL树)C++实现
08-10
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉搜索树，它的主要特点是左右子树的高度差不超过1，以此保持树的平衡，从而确保搜索、插入和删除等操作的时间复杂度为O(log n)。AVL树是最早被提出的自平衡二叉...
7.6平衡二叉树（AVL树）
weixin_44897707的博客
11-26 602
平衡二叉树（AVL树） 平衡二叉树是一种二叉排序树，平衡二叉树的出现是为了解决二叉搜索树因为高度太高而查找效率下降的问题。 如：对于数组a[10]={3,2,1,4,5,6,7,10,9,8}.分别构建二叉搜索树和平衡二叉树。 如果要查找结点8，左边二叉搜索树搜索过程为：3->4->5->6->7->10->9->8,要查找8次。而平衡二叉树搜索过程为：4->7->9->8,只要搜索8次，可以看出当二叉搜索树高度变得很高之后搜索效率会下降很多。
数据机构之二叉树
梦的灰色边沿...
01-07 2771
二叉树一、二叉树的定义和分类1、二叉树的定义　　二叉树是一种特定的树，每个结点最多有两棵子树，并且左右子树不能交换位置。　　这意味着下面几棵树是完全不同的树。2、几种特殊的二叉树满二叉树　　高度为h并且结点数为2^h-1的树为满二叉树，即每个层都有最大结点数。　　因此满二叉树的叶子结点都在最底下一层。并且若按层按顺序为结点编号对于结点i，如果有双亲，必为(向下取整)(i/2),如果有孩子，左孩子必为
二叉排序树
weixin_33709364的博客
11-09 197
二叉排序树又称“二叉查找树”、“二叉搜索树”。 二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 它的左、右子树也分别为二叉排序树。   二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个依据关键字的有序序列，一...
二叉排序树，AVL树，B树（多路查找树）,B+树
XieCH1995的博客
03-30 624
一.二叉排序树 1.定义： 对于一颗二叉树，它的左子树若不为空，则左子树上所有结点的值小于它的根结点的值，若右子树不为空，则右子树上的所有结点的值大于它的根结点的值。且它的左右子树也分别为二叉排序树。 2.总结： 二叉排序树是以链接的方式存储，保持了链接存储结构在执行插入或删除操作上不用移动元素的优点，只要找到合适的插入和删除位置后，仅需修改链接指针即...
平衡二叉树与AVL树详解
"这篇内容主要介绍了高级数据结构中的平衡二叉树，特别是AVL树的概念、性质以及旋转操作。" 在计算机科学中，高级数据结构是处理复杂数据组织方式的关键，其中平衡二叉树是一种重要的数据结构，它优化了基本二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值