AVl平衡二叉树的增、删、查 java实现

最新推荐文章于 2021-10-12 08:43:41 发布
最新推荐文章于 2021-10-12 08:43:41 发布
阅读量208 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 二叉树 java 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40965479/article/details/106730361
版权

为什么引入AVL树？

给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在.
在这里插入图片描述
上边BST 存在的问题分析:

  • 左子树全部为空，从形式上看，更像一个单链表.
  • 插入速度没有影响 查询速度明显降低(因为需要依次比较),
  • 不能发挥BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢

解决方案-平衡二叉树(AVL)

基本介绍

  • 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树，可以保证查询效率较高。

特点：

  • 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，
  • 并且左右两个子树都是一棵平衡二叉树。

在进行代码书写时，我们先了解几个概念

  1. 左旋转
    在这里插入图片描述

  2. 右旋转
    在这里插入图片描述

  3. 双旋转
    在这里插入图片描述

代码实现

Node

package com.edu.tree.avltree;

/**
 * @Date 2020/6/11 8:54
 * @Author by LiShiYan
 * @Description AVL树结点
 */
public class Node {
    private Integer data;
    private Node left;
    private Node right;

    public Node(Integer data) {
        this.data = data;
    }

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

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

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

    /**
     * 左旋转
     */
    private void leftRotate() {
        //创建新的结点，以当前根结点的值
        Node newNode = new Node(data);
        //把新的结点的左子树设置成当前结点的左子树
        newNode.left = this.left;
        //把新的结点的右子树设置成带你过去结点的右子树的左子树
        newNode.right = this.right.left;
        //把当前结点的值替换成右子结点的值
        this.data = right.data;
        //把当前结点的右子树设置成当前结点右子树的右子树
        this.right = this.right.right;
        //把当前结点的左子树(左子结点)设置成新的结点
        this.left = newNode;
    }

    /**
     * 左旋转
     */
    private void rightRotate() {
        //创建新的结点，以当前根结点的值
        Node newNode = new Node(data);
        //把新的结点的右子树设置成当前结点的右子树
        newNode.right = this.right;
        //把新的结点的左子树设置成带你过去结点的左子树的右子树
        newNode.left = this.left.right;
        //把当前结点的值替换成左子结点的值
        this.data = this.left.data;
        //把当前结点的左子树设置成当前结点左子树的左子树
        this.left = this.left.left;
        //把当前结点的右子树(右子结点)设置成新的结点
        this.right = newNode;
    }

    /**
     * 查找要删除结点的父结点
     *
     * @param data 删除结点
     * @return 删除结点的父结点， 如果没有返回null
     */
    public Node searchParent(int data) {
        //如果当前结点是删除结点的父节点，返回true
        boolean isParent = (this.left != null && this.left.data == data) || (this.right != null && this.right.data == data);
        if (isParent) {
            //返回当前结点
            return this;
        } else {
            //如果查找的值小于当前结点的值，并且当前结点的左子结点不为空
            if (data < this.data && this.left != null) {
                //向左子树递归
                return this.left.searchParent(data);
            } else if (data >= this.data && this.right != null) {
                //向右子树递归
                return this.right.searchParent(data);
            } else {
                //没有找到父结点
                return null;
            }
        }
    }

    /**
     * 查找要删除的结点
     *
     * @param data 要删除结点的值
     * @return 如果找到返回该结点，否则返回null
     */
    public Node search(int data) {
        //找到该结点
        if (data == this.data) {
            return this;
        }
        //如果查找的值小于当前结点，向左子树递归查找
        else if (data < this.data) {
            //如果左子树为空，返回null
            if (this.left == null) {
                return null;
            }
            return this.left.search(data);
        }
        //如果查找的值大于等于当前结点，向右子树递归查找
        else {
            if (this.right == null) {
                return null;
            }
            return this.right.search(data);
        }
    }

    /**
     * 递归的形式添加节点
     *
     * @param node 要添加的结点
     */
    public void add(Node node) {
        if (node == null) {
            return;
        }
        //判断传入结点的值和当前子树的根节点的值的关系
        //1.添加结点的值小于当前结点的值
        if (node.data < this.data) {
            if (this.left == null) {
                //当前结点的left指针指向node结点
                this.left = node;
            } else {
                //递归的向左子树添加
                this.left.add(node);
            }
        } else {
            //2.添加的结点值大于 当前结点的值
            if (this.right == null) {
                //当前结点的right指针指向node结点
                this.right = node;
            } else {
                //递归向右子树添加
                this.right.add(node);
            }
        }

        //当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
        if (rightHeight() - leftHeight() > 1) {
            //如果它的右子树的左子树的高度大于它的右子树的右子树的高度
            if (right != null && right.leftHeight() > right.rightHeight()) {
                //先对右子结点进行右旋转
                right.rightRotate();
                //然后在对当前结点进行左旋转
                leftRotate(); //左旋转..
            } else {
                //直接进行左旋转即可
                leftRotate();
            }
            return; //必须要!!!
        }

        //当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
        if (leftHeight() - rightHeight() > 1) {
            //如果它的左子树的右子树高度大于它的左子树的高度
            if (left != null && left.rightHeight() > left.leftHeight()) {
                //先对当前结点的左结点(左子树)->左旋转
                left.leftRotate();
                //再对当前结点进行右旋转
                rightRotate();
            } else {
                //直接进行右旋转即可
                rightRotate();
            }
        }
    }

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

    public Integer getData() {
        return data;
    }

    public void setData(Integer data) {
        this.data = data;
    }

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

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

AvlTree

package com.edu.tree.avltree;

/**
 * @Date 2020/6/13 9:28
 * @Author by LiShiYan
 * @Description 平衡二叉树
 */
public class AvlTree {
    private Node root;

    public Node getRoot() {
        return root;
    }


    /**
     * 1. 返回的 以node 为根结点的二叉排序树的最小结点的值
     * 2. 删除node 为根结点的二叉排序树的最小结点
     *
     * @param node 传入的结点（当做二叉排序树的根节点）
     * @return 以node为根节点的二叉排序树的最小结点的值
     */
    public int delRightTreeMin(Node node) {
        Node targetNode = node;
        //循环的查找左子结点，就会找到最小值
        while (targetNode.getLeft() != null) {
            targetNode = targetNode.getLeft();
        }
        //循环结束，此时target指向了最小的结点
        //删除最小结点
        delNode(targetNode.getData());

        return targetNode.getData();
    }

    /**
     * @param data 要删除结点
     */
    public void delNode(int data) {
        if (root == null) {
            return;
        } else {
            //1.找到要删除结点
            Node targetNode = search(data);
            //如果没有找到要删除的结点，返回
            if (targetNode == null) {
                return;
            }
            //如果当前这颗二叉排序树只有一个结点
            if (root.getLeft() == null && root.getRight() == null) {
                root = null;
                return;
            }
            //2.找到targetNode父结点
            Node parent = searchParent(data);
            //3.1如果删除的结点是叶子结点
            if (targetNode.getLeft() == null && targetNode.getRight() == null) {
                //判断targetNode是父结点的左子结点还是右子结点
                if (parent.getLeft() != null && parent.getLeft().getData() == data) {
                    //左子结点
                    parent.setLeft(null);
                }
                if (parent.getRight() != null && parent.getRight().getData() == data) {
                    //右子结点
                    parent.setRight(null);
                }
            }
            //3.2 删除有两颗子树的节点
            else if (targetNode.getLeft() != null && targetNode.getRight() != null) {
                //1.找到最小结点
                int minValue = delRightTreeMin(targetNode.getRight());
                //2.设置删除结点的值为最小结点的值
                targetNode.setData(minValue);
            }
            //3.3 删除只有一颗子树的结点
            else {
                //1.如果要删除的结点有 左子结点: targetNode.getLeft()
                if (targetNode.getLeft() != null) {
                    //父结点不为空
                    if (parent != null) {
                        //1.2如果targetNode是 parent 左子结点
                        if (parent.getLeft().getData() == data) {
                            //将parent 左结点指针 指向targetNode的左子结点
                            parent.setLeft(targetNode.getLeft());
                        } else {
                            //1.3如果targetNode是 parent 右子结点
                            parent.setRight(targetNode.getLeft());
                        }
                    } else {
                        //父结点为空，让目标结点的左节点成为根结点
                        root = targetNode.getLeft();
                    }
                } else {
                    //2. 如果要删除的结点有 右子结点: targetNode.getRight()
                    if (parent != null) {
                        //2.2如果targetNode是 parent 左子结点
                        if (parent.getLeft().getData() == data) {
                            parent.setLeft(targetNode.getRight());
                        } else {
                            //2.3如果targetNode是 parent 右子结点
                            parent.setRight(targetNode.getRight());
                        }
                    } else {
                        //父结点为空，让目标结点的右节点成为根结点
                        root = targetNode.getRight();
                    }
                }
            }
        }
    }

    /**
     * 查找要删除的结点
     *
     * @param data 要删除结点
     * @return 以删除结点
     */
    public Node search(int data) {
        if (root == null) {
            return null;
        } else {
            return root.search(data);
        }
    }

    /**
     * 查找父结点
     *
     * @param data 要删除结点
     * @return 要删除结点的父结点
     */
    public Node searchParent(int data) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(data);
        }
    }

    /**
     * 添加结点
     *
     * @param node 结点
     */
    public void add(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.add(node);
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序树为空，不能遍历");
        }
    }
}
AKA石头
关注
专栏目录
平衡二叉树（AVL）
羽翼的博客
06-18 781
平衡二叉树首先是一棵二叉排序树 二叉排序树：对于每个节点，左孩子比本身小，右孩子比本身大 首先我们来实现一个二叉排序树。 //节点结构体 struct TreeNode{ int val; //节点值 TreeNode* left; TreeNode* right; TreeNode(int val){ //结构体构造方法 this->val = val; this->left=NULL; this->right=NULL; } }; 然后是二叉排序树的插入算
java实现平衡二叉树
qq_45731129的博客
08-31 959
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树，可以保证查询效率较高。具有以下特点: 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。举例说明, 看看下面哪些AVL树,为什么?平衡二叉搜索树的左右子树，高度差不能大于1，所以前两个满足。...
平衡二叉树平衡二叉树（AVL）--查找、删除、插入（Java实现）
weixin_34326558的博客
05-08 163
间时紧张，先记一笔，后续优化与完善。                 媒介                        后面一篇文章，笔者就二叉找查树行进了一些解释与实现，这篇文章笔者将会就平衡二叉树                    做一些总结与实现。读者若不懂得二叉找查树的话，可以考参这篇文章：                    http://blog.csdn.net/k...
Java实现创建平衡二叉树(AVL 树)和AVL树的增删改查
当一个合格的软件工程师
10-12 2645
11.5 平衡二叉树(AVL 树) 11.5.1 看一个案例(说明二叉排序树可能的问题) 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在。 左边 BST 存在的问题分析: 左子树全部为空，从形式上看，更像一个单链表。 插入速度没有影响。 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。 解决方案-平衡二叉树(AVL) 11.5.2 基本介绍 平衡二叉树也叫平衡二叉搜索树（Self-balan
AVL添加平衡二叉树，是一种二叉排序树，其中每个结点的左子树和右子树的高度差至多等于1。-icoding-数据结构-C-typedef struct node{ int val；
风起
06-14 814
AVL添加 平衡二叉树，是一种二叉排序树，其中每个结点的左子树和右子树的高度差至多等于1。 它是一种高度平衡的二叉排序树。现二叉平衡树结点定义如下：
AVL树删除算法 (使用树高)
Day_dreamers的博客
08-31 403
以下代码大部分直接搬运自Mark Allen 的数据结构与算法分析， 略有改动。 鉴于书本及示例代码均未提及删除操作， 在此提供一种思路。 头文件： //avltree.htypedef int ElementType; #ifndef _AVLTREE_H_ #define _AVLTREE_H_ struct AvlNode; typedef AvlNode * AvlTre
排序二叉树 AVL树 哈夫曼树增删改查Java实现
05-11
在这个主题中，我们将探讨三种特殊的树类型：排序二叉树、AVL树和哈夫曼树，以及如何使用Java语言来实现它们的基本操作，如增、删、改、查。 首先，排序二叉树（Sorted Binary Tree）是一种特殊的二叉树，其中每个...
Java中AVL平衡二叉树实现Map_(仿照TreeMap和TreeSet)1
08-08
"Java中AVL平衡二叉树实现Map_(仿照TreeMap和TreeSet)1" 本文将详细介绍Java中AVL平衡二叉树实现Map的知识点，以便读者更好地理解和应用AVL树在Java中的实现。 一、AVL树的概念和特点 AVL树是一种自平衡二叉搜索...
使用Java实现平衡二叉树(AVL树)
最新发布
08-03
这段 Java 代码实现了一个 AVL 树（平衡二叉搜索树）的数据结构。 **类和内部类**： * `AVLTree`：主类，包含 AVL 树的操作方法和属性。 * `TreeNode`：内部类，代表 AVL 树的节点，包含节点值、左右子树指针、父...
基于java实现的平衡二叉树源码.zip
09-27
在Java中实现平衡二叉树，我们可以选择多种类型，例如AVL树和红黑树，这两种都是自平衡二叉搜索树。 **AVL树**： AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此...
平衡二叉树(AVL)
凡　　尘
12-04 640
上一篇我们聊过，二叉查找树不是严格的O(logN)，如果找到一种方法，使得二叉查找树不受输入序列和插入结点等的影响，始终保持平衡状态，从而达到很好的检索效率．平衡二叉树就是基于此目的而产生的． 定义：平衡二叉树或为空树,或为如下性质的二叉排序树(平衡二叉树是一种特殊的二叉排序树): （1）左右子树深度之差的绝对值不超过1; （2）左右子树仍然为平衡二叉树. 平衡因子BF=左子树深度－右子树深度
平衡二叉树（AVL树）
weixin_41590779的博客
07-26 183
定义 平衡二叉树是一种二叉排序树，其中每一个结点的左子树和右子树的高度差至多等于1。 平衡二叉树的前提是一棵二叉排序树，二叉排序树的查找性能受树的形状影响较大，所以需要对二叉排序树进行平衡处理，常见的方法有AVL、红黑树、Treap等。 平衡因子 平衡二叉树上的结点左子树的深度减去右子树的深度的值成为该结点的平衡因子，平衡因子取值只能为0，-1，1。 最小不平衡子树 距离插入结点最近的，且以平衡因子的绝对值大于1的结点为根结点的子树。 平衡二叉树的平衡过程 RR型旋转：插入结点在最小不平衡子树的左子树的左
平衡二叉树 AVL树
人工智能视觉分析算法学习实践和经验分享。
04-17 520
平衡二叉树平衡二叉树的定义最小不平衡子树平衡二叉树的实现原理算法实现参考文献 平衡二叉树的定义 平衡二叉树又称：Self-Balancing Binary Search Tree 或 Height-Balanced Binary Search Tree：高度平衡的二叉排序树。 平衡二叉树：是一种二叉排序树，它的每一个节点的左子树和右子树的高度差小于等于一。 由两位俄罗斯数学家 G M Adelso...
【Java数据结构】AVL树(平衡二叉树)总结（增加，删除操作，四种旋转）
懂技术的猫
07-15 663
AVL树本质上还是一棵二叉搜索树，AVL = BST + 平衡操作 所以它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。 3.树中的每个左子树和右子树都是AVL树 也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。 为何引入AVL： ...
AVL树和Java实现
Jintao_Ma的博客
03-30 1111
AVL树和Java实现 一.AVL树的特点 二.Java实现 三.增删改查时间复杂度 一.AVL树的特点 1.1 它是一种平衡二叉查找树的一种实现方式 1.2 任何节点的两个子树的高度最大差别为1 由于上面的1.2特性，可知，它的做多节点数为一棵满树，最少节点数为斐波那契数列。 二.Java实现 理论可参照此文:http://www.cnblogs.com/skywang1234
数据结构之平衡二叉树（AVL）
ZHAO
06-14 281
一、概念    平衡二叉树是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1。    平衡因子（BF）：结点的左子树深度减去右子树深度的值称为平衡因子。    最小不平衡子树：插入进来一个元素后，变得不平衡的最小部分。二、实现原理三、代码实现...
数据结构之－平衡二叉树(AVL)
u011298001的博客
10-24 400
背景 不同结构的二叉查找树，查找效率有很大的不同。如何解决这个问题呢？关键在于如何最大限度的减小树的深度。正是基于这个想法，平衡二叉树出现了。 前言 平衡二叉搜索树（英语：Balanced Binary Tree）是一种结构平衡的二叉搜索树。 它能在O(log n)时间内完成插入、查找和删除操作。它除了具备二叉查找树的基本特征之外，还具有一个非常重要的特点：它的左子树和右子树都是平衡二叉树，...
AVL树详解：平衡二叉树的概念、旋转操作与Java实现
"平衡二叉树详解及java代码的实现" 平衡二叉树是一种特殊的二叉树结构，其主要特点是保持树的平衡，确保在树的任何层面上，左右子树的高度差不超过1，以此来优化二叉搜索树的性能。这种平衡特性使得在平衡二叉树中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值