平衡二叉树

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量568 收藏
点赞数
文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56280646/article/details/130584282
版权

平衡二叉树

文章目录

平衡二叉树其实就是比排序二叉树多了旋转方法，具体实现二叉排序树，请参考：(2条消息) 二叉排序树_Land-Cruise的博客-CSDN博客

二叉排序树存在的问题

当给出一个数列{1,2,3,4,5,6}，创建一个二叉排序树，就会创建这样一棵二叉排序树

在这里插入图片描述

左边BST 存在的问题分析:

  1. 左子树全部为空，从形式上看，更像一个单链表.
  2. 插入速度没有影响
  3. 查询速度明显降低(因为需要依次比较), 不能发挥BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢
  4. 解决方案-平衡二叉树(AVL)

基本介绍

  1. 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。
  2. 具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。

实现平衡二叉树

计算二叉树高度的方法

//返回以当前节点为根节点的树的高度
    public int height(){
        return Math.max(left==null?0: left.height(), right==null?0: right.height())+1;
    }

计算左子树高度的方法

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

计算右子树高度的方法

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

左旋转

要求: 给你一个数列，创建出对应的平衡二叉树.数列 {4,3,6,5,7,8}

在这里插入图片描述

具体步骤：

  1. 创建一个新的节点newNode(以4这个值创建)，创建一个新的节点，值等于当前根节点的值
  2. 把新的节点的左子树设置成当前节点的左子树
  3. 把新的节点的右子树设置成当前节点的右子树的左子树
  4. 把当前节点的值替换成右子节点的值
  5. 把当前节点的右子树替换成右子树的右子树
  6. 当前节点的左子树指向刚才创建的新的节点

代码实现

//左旋转的方法
    private void leftRotate(){
        //创建新的节点，以当前根节点的值创建的
        Node newNode = new Node(value);
        //把新的节点的左子树设置成当前节点的左子树
        newNode.left = left;
        //把新的节点的右子树设置成当前节点的右子树的左子树
        newNode.right = right.left;
        //把当前节点的值替换成右子节点的值
        value = right.value;
        //把当前节点的右子树替换成右子树的右子树
        right = right.right;
        //当前节点的左子树指向刚才创建的新的节点
        left = newNode;
    }

右旋转

要求: 给你一个数列，创建出对应的平衡二叉树.数列 {10,12, 8, 9, 7, 6}

在这里插入图片描述

具体步骤：

  1. 创建新的节点，以当前根节点的值创建
  2. 把新的节点的右子树设置成当前节点的右子树
  3. 把新的节点的左子树设置成当前节点左子树的右子树
  4. 把当前节点的值替换成左子节点的值
  5. 把当前节点的左子树替换成左子树的左子树
  6. 把当前节点的右子树指向刚才创建的新的节点

代码实现

//右旋转的方法
    private void rightRotate(){
        //创建新的节点，以当前根节点的值创建
        Node newNode = new Node(value);
        //把新的节点的右子树设置成当前节点的右子树
        newNode.right = right;
        //把新的节点的左子树设置成当前节点左子树的右子树
        newNode.left = left.right;
        //把当前节点的值替换成左子节点的值
        value = left.value;
        //把当前节点的左子树替换成左子树的左子树
        left = left.left;
        //把当前节点的右子树指向刚才创建的新的节点
        right = newNode;
    }

双旋转

前面的两个数列，进行单旋转(即一次旋转)就可以将非平衡二叉树转成平衡二叉树,但是在某些情况下，单旋转不能完成平衡二叉树的转换。比如数列
int[] arr = { 10, 11, 7, 6, 8, 9 }; 运行原来的代码可以看到，并没有转成 AVL树.
int[] arr = {2,1,6,5,7,3}; // 运行原来的代码可以看到，并没有转成 AVL树

在这里插入图片描述

具体步骤：

  1. 在加入数据后判断左子树的左子树和右子树的高度，如果左子树高度高于右子树则右旋转，否则左旋转
  2. 在加入数据后判断右子树的左子树和右子树的高度，如果左子树高度高于右子树则右旋转，否则左旋转

代码实现

在添加的方法中加入以下代码就完成了双旋转操作

//当添加完一个节点后，如果右子树的高度比左子树的高度差大于1，则右旋转
        if((rightHeight()-leftHeight())>1){
            //判断右子树的左子树的高度大于右子树的高度  满足就先右旋转
            if(right!=null&&right.leftHeight()>right.leftHeight()){
                right.rightRotate();
            }
            leftRotate();//左旋转
            return;//终端下面的执行
        }
        //当添加完一个节点后，如果左子树的高度比右子树的高度差大于1，则右旋转
        if((leftHeight()-rightHeight())>1){
            //判断左子树的右子树的高度大于右子树的高度  满足就先左旋转
            if(left!=null&&left.rightHeight()>left.leftHeight()){
                left.leftRotate();
            }
            rightRotate();//右旋转
        }

完整代码

节点类

package com.datestructures.tree.AVLTree;

public class Node {
    int value;
    Node left;
    Node right;

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

    //添加节点的方法  递归的形式添加  需要满足二叉排序树的要求
    public void add(Node node){
        if(node == null){
            return;
        }
        //判断传入的节点的值 和当前子树的根节点的值的关系
        if(node.value<this.value){//添加的节点的值小于当前节点的值
            //如果当前节点左子节点为null  那么就挂在左子节点上
            if(this.left==null){
                this.left = node;
            }else{
                //递归的向左子树添加
                this.left.add(node);
            }
        }else{//添加的节点的值大于当前节点的值
            //如果当前节点右子节点为null  那么就挂在右子节点上
            if(this.right==null){
                this.right = node;
            }else {
                this.right.add(node);
            }
        }
        //当添加完一个节点后，如果右子树的高度比左子树的高度差大于1，则右旋转
        if((rightHeight()-leftHeight())>1){
            //判断右子树的左子树的高度大于右子树的高度  满足就先右旋转
            if(right!=null&&right.leftHeight()>right.leftHeight()){
                right.rightRotate();
            }
            leftRotate();//左旋转
            return;//终端下面的执行
        }
        //当添加完一个节点后，如果左子树的高度比右子树的高度差大于1，则右旋转
        if((leftHeight()-rightHeight())>1){
            //判断左子树的右子树的高度大于右子树的高度  满足就先左旋转
            if(left!=null&&left.rightHeight()>left.leftHeight()){
                left.leftRotate();
            }
            rightRotate();//右旋转
        }
    }
    /**
     * 查找要删除的节点
     * @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 返回的是要删除节点的父节点  如果没有返回null
     */
    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>=this.value&&this.right!=null){
                return this.right.searchParent(value);
            }else {
                return null;//没有找到父节点
            }
        }
    }
    //返回左子树的高度
    public int leftHeight(){
        if(left==null){
            return 0;
        }
        return left.height();
    }
    //返回右子树的高度
    public int rightHeight(){
        if(right==null){
            return 0;
        }
        return right.height();
    }
    //返回以当前节点为根节点的树的高度
    public int height(){
        return Math.max(left==null?0: left.height(), right==null?0: right.height())+1;
    }
    //左旋转的方法
    private void leftRotate(){
        //创建新的节点，以当前根节点的值创建的
        Node newNode = new Node(value);
        //把新的节点的左子树设置成当前节点的左子树
        newNode.left = left;
        //把新的节点的右子树设置成当前节点的右子树的左子树
        newNode.right = right.left;
        //把当前节点的值替换成右子节点的值
        value = right.value;
        //把当前节点的右子树替换成右子树的右子树
        right = right.right;
        //当前节点的左子树指向刚才创建的新的节点
        left = newNode;
    }
    //右旋转的方法
    private void rightRotate(){
        //创建新的节点，以当前根节点的值创建
        Node newNode = new Node(value);
        //把新的节点的右子树设置成当前节点的右子树
        newNode.right = right;
        //把新的节点的左子树设置成当前节点左子树的右子树
        newNode.left = left.right;
        //把当前节点的值替换成左子节点的值
        value = left.value;
        //把当前节点的左子树替换成左子树的左子树
        left = left.left;
        //把当前节点的右子树指向刚才创建的新的节点
        right = newNode;
    }
    //中序遍历
    public void infixOreder(){
        if(this.left!=null){
            this.left.infixOreder();
        }
        System.out.println(this);
        if(this.right!=null){
            this.right.infixOreder();
        }
    }

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

平衡二叉树的实现类

package com.datestructures.tree.AVLTree;


public class AVLTree {
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点的方法
    public void add(Node node) {
        if (root == null) {
            //如果root为空 则让root指向node
            root = node;
        } else {
            root.add(node);
        }
    }

    //查找要删除的节点
    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 = null;
                return;
            }
            //2.找到要删除的节点的父节点 parentNode
            Node parentNode = searchParent(value);
            //如果要删除的节点时叶子结点
            if (targetNode.left == null & targetNode.right == null) {//要删除的节点没有左子树和右子树
                //判断targetNode是父节点的左子节点还是右子节点
                if (parentNode.left != null && parentNode.left.value == value) {
                    parentNode.left = null;//左子节点
                } else if (parentNode.right != null && parentNode.right.value == value) {
                    parentNode.right = null;//右子节点.
                }
            } else if (targetNode.left != null && targetNode.right != null) {//要删除的节点有左子树和右子树
                int minVal = delRightTreeMin(targetNode.right);
                targetNode.value = minVal;
            } else {//要删除的节点有一棵子树
                if (parentNode != null) {
                    //如果要删除的节点有左子节点
                    if (targetNode.left != null) {
                        if (parentNode.left.value == value) {//如果targetNode是parent的左子节点
                            parentNode.left = targetNode.left;
                        } else {//如果targetNode是parent的右子节点
                            parentNode.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }
                } else {
                    if (parentNode != null) {
                        if (parentNode.left.value == value) {//如果targetNode是parent的左子节点
                            parentNode.left = targetNode.right;
                        } else {//如果targetNode是parent的右子节点
                            parentNode.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;
                    }
                }
            }
        }
    }

    /**
     * 1.返回最小值  2.删除以node为根节点的最小值的那个节点
     *
     * @param node 传入的节点   当做新的二叉排序树的根节点
     * @return 返回以node 为根节点的二叉排序树的最小节点的值
     */
    public int delRightTreeMin(Node node) {
        Node target = node;
        //循环的查找左节点，就会找到最小值
        while (target.left != null) {
            target = target.left;
        }
        //这时target就指向了最小值的节点
        delNode((target.value));
        return target.value;
    }

    //中序遍历
    public void infixOrder() {
        if (root != null) {
            root.infixOreder();
        } else {
            System.out.println("当前二叉排序树为空 不能遍历");
        }
    }
}

测试类

package com.datestructures.tree.AVLTree;

public class AVLTreeDemo {
    public static void main(String[] args) {
        //int[] arr = {4,3,6,5,7,8};  左旋转测试
        //int[] arr = {10,12,8,9,7,6};  右旋转测试
        int[] arr = {10,11,7,6,8,9};//左右旋转的问题数列  双旋转
        //创建一个AVLTree对象
        AVLTree avlTree = new AVLTree();
        //添加节点
        for (int i = 0; i < arr.length; i++) {
            avlTree.add(new Node(arr[i]));
        }
        //中序遍历
        System.out.println("中序遍历");
        avlTree.infixOrder();
        System.out.println("平衡处理");
        System.out.println(avlTree.getRoot().height());
        System.out.println("左子树的高度="+avlTree.getRoot().leftHeight());
        System.out.println("右子树的高度="+avlTree.getRoot().rightHeight());
        System.out.println(avlTree.getRoot());
    }
}
Admin-fqw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
平衡二叉树AVL操作模板
09-04
主要介绍了平衡二叉树AVL操作模板,需要的朋友可以参考下
平衡二叉树详解 通俗易懂
热门推荐
半亩方糖
01-10 12万+
平衡二叉树（AVL） 阅读之前请先了解 二叉搜索树 平衡二叉树定义：任意节点的子树的高度差都小于等于 1 1. 为什么使用「平衡二叉树」 二叉树能提高查询的效率 O(logn)，但是当你插入 {1,2,3,4,5,6} 这种数据的时候，你的二叉树就像一个「链表」一样，搜索效率变为 O(n) 于是在 1962 年，一个姓 AV 的大佬（G. M. Adelson-Velsky） 和一个姓 L 的大佬（ Evgenii Landis）提出「平衡二叉树」（AVL） 。 于是插入 {1,2,3,4,5,6}
平衡二叉树详解
尽量致力于发表微服务、中间件和算法等原创作品。
06-17 4万+
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡二叉树大部分操作和二叉查找树类似，主要不同在于插入删除的时候平衡二叉树的平衡可
c++实现平衡二叉树管理的学生管理系统项目
07-02
1. 完成 学生, 课程,选课,成绩 的增删改查 学生ID 学生名 选课名 成绩 001 张三 C++ 60 ...1.采用平衡二叉树的可靠管理，源码规范，文档齐备：80分 2.采用动态数组的可靠管理，源码规范，文档齐备：60分
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 999
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 795
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 293
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java多线程创建方式
weixin_57763462的博客
05-28 1076
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 509
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 1029
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1067
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
SpringCloud-OpenFeign
qq_74748121的博客
05-30 566
OpenFeign早期版本（例如要求服务提供方在1秒内处理业务逻辑并返回响应。如果超过1秒没有返回，OpenFeign会直接报错，不会等待服务执行。随着版本的更新，OpenFeign已经对此做出了调整或优化（例如 2021.0.1）。超时报错如下：修改超时时间：1.在远程调用方的 application.yml 中配置，指定某个服务提供方的调用超时时间feign:client:config:product: # 服务名connect-timeout: 5000 # 配置指定服务连接超时时间。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 164
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
【JAVA |String类】JAVA中的String类常见用法详解
YKX0000的博客
05-30 899
在JAVA中的字符串存储是可以直接使用String这个引用数据类型，不像C语言表示字符串只能使用字符数组或者字符指针，使我们操作起来更方便，更符合不符合面相对象的思想。
继承与无参构造器
2301_79842503的博客
05-30 228
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
Servlet搭建博客系统
Smarmot的博客
05-31 635
现在我们可以使用Servlet来搭建一个动态(前后端可以交互)的博客系统.(使用Hexo只能实现一个纯静态的网页,即只能在后台自己上传博客)
平衡二叉树完全二叉树
09-21
平衡二叉树和完全二叉树是两种不同的二叉树结构。 平衡二叉树是一种特殊的二叉搜索树，或者为空树，或者满足以下条件：它的左子树和右子树的深度之差（平衡因子）的绝对值不超过1，并且左子树和右子树都是一颗平衡二叉树。平衡二叉树的设计可以有效地解决二叉搜索树退化成链表的问题，同时保持了插入、查找和删除操作的平均时间复杂度为O(logN)。 而完全二叉树是一种特殊的二叉树结构，它除了最后一层可能不是满的外，其他层都是满的，而且最后一层的节点都集中在最左边。换句话说，深度为h的完全二叉树除了第h层外，其他各层的节点数都达到最大个数。完全二叉树具有高效的存储结构和查找性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值