平衡二叉树的具体实现

最新推荐文章于 2024-08-02 11:43:10 发布
最新推荐文章于 2024-08-02 11:43:10 发布
阅读量194 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉树 算法 数据结构 java
原文链接：https://www.bilibili.com/video/BV1E4411H73v?p=136
版权

文章参考视频https://www.bilibili.com/video/BV1E4411H73v?p=141
平衡二叉树首先是一个排序二叉树。
特点如下：

在这里插入图片描述

创建二叉树的代码如下

package 算法.树;

public class BinarySortTreeDemo {
public static void main(String[] args) {
int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};
BinarySortTree binarySortTree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
binarySortTree.add(new SortTreeNode(arr[i]));
}
binarySortTree.midOrder();
binarySortTree.delNode(2);
binarySortTree.delNode(5);
binarySortTree.delNode(9);
binarySortTree.delNode(12);
binarySortTree.delNode(7);
binarySortTree.delNode(3);
binarySortTree.delNode(10);

     binarySortTree.delNode(1);

    System.out.println("");
    binarySortTree.midOrder();
    System.out.println(binarySortTree.getRoot());
}

}

//创建二叉排序树
class BinarySortTree {
private SortTreeNode root;

//添加结点的方法
public void add(SortTreeNode node) {
    if (root == null) {
        root = node;
    } else {
        root.add(node);
    }
}

public SortTreeNode getRoot() {
    return root;
}

//查找要删除的结点
public SortTreeNode search(int value) {
    if (root == null) {
        return null;
    } else {
        return root.search(value);
    }
}

//查找要删除结点的父节点
public SortTreeNode searchParent(int value) {
    if (root == null) {
        return null;
    } else {
        return root.searchParent(value);
    }
}

//删除结点
public void delNode(int value) {
    if (root == null) {
        return;
    } else {
        //找到要删除的结点
        SortTreeNode targetNode = root.search(value);
        if (targetNode == null) {
            //没找到
            return;
        }
        //如果找到，但是根节点的左和右都为空，证明根节点就是要找的点，且只有一个根节点
        if (root.left == null && root.right == null) {
            root = null;
            return;
        }

        //根据三种情况开始判断。
        SortTreeNode parentNode = root.searchParent(value);
        //第一种情况如果要删除的结点是叶子结点
        if (targetNode.left == null && targetNode.right == null) {
            //判断删除结点是父节点的左节点还是右结点
            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) {
            //先判断targetNode有两个子结点的情况，因为只有一个子节点的判断过于繁琐
            SortTreeNode temp = targetNode.right;
            while (temp.left != null) {
                temp = temp.left;//循环找到targetNode右子树的最小值
            }
            //删除targetNode右子树最小的结点(最小的结点要么只有右子树，要么没有子结点，符合另外两种情况)
            delNode(temp.value);
            //把temp中的数据赋给target
            targetNode.value = temp.value;

        } else {
            //删除的结点只有一个结点

            if (targetNode.left != null) {//删除结点的左子节点不空
                //要考虑当targetNOde是根节点,没有父节点，且它只有一个子节点
                if (parentNode != null) {//父节点不为空
                    if (parentNode.left != null && parentNode.left.value == targetNode.value) {
                        parentNode.left = targetNode.left;
                    } else {
                        parentNode.right = targetNode.left;
                    }
                } else {
                    root = targetNode.left;
                }
            } else {//targetNode的右子节点不为空
                if (parentNode != null) {
                    if (parentNode.left != null && parentNode.left.value == targetNode.value) {
                        parentNode.left = targetNode.right;
                    } else {
                        parentNode.right = targetNode.right;
                    }
                } else {
                    root=targetNode.right;
                }

            }
        }
    }

}

//中序遍历,对二叉排序树进行中序遍历，刚好是顺序的
public void midOrder() {
    if (root != null) {
        root.midOrder();
    } else {
        System.out.println("排序树为空");
    }
}

}

class SortTreeNode {
int value;
SortTreeNode left;
SortTreeNode right;

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

//查找要删除结点的方法
public SortTreeNode search(int value) {
    if (this.value == value) {
        return this;
    } else if (value < this.value) {
        if (this.left == null) {
            return null;
        }
        return this.left.search(value);
    } else {//要查找的值不小于当前结点的value
        if (this.right == null) {
            return null;
        }
        return this.right.search(value);
    }
}

//查找要删除结点的父节点
public SortTreeNode searchParent(int value) {
    if ((this.left != null && this.left.value == value) ||
            (this.right != null && this.right.value == value)) {
        return this;
    } else {
        if (this.left != null && value < this.value) {
            return this.left.searchParent(value);
        } else if (this.right != null && value >= this.value) {
            return this.right.searchParent(value);

        } else {
            return null;//没有父节点
        }
    }

}

//添加结点的方法，要满足二叉排序树的要求
public void add(SortTreeNode node) {
    if (node == null) {
        return;
    }
    //判断传入的结点的值和根节点的关系
    if (node.value < this.value) {
        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 midOrder() {
    if (this.left != null) {
        this.left.midOrder();
    }
    System.out.println(this);
    if (this.right != null) {
        this.right.midOrder();
    }
}

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

}

其中要特别说明一下的是，删除二叉排序树的结点时的情况

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

平衡二叉树是建立在排序二叉树的一个改进，特点如下

在左子树和右子树的高度差超过一时候，会进行一个旋转调整
在这里插入图片描述
左旋的思路,右旋同左旋原来类似。
在这里插入图片描述
上面的思路还有个特殊情况需要处理
在这里插入图片描述
解决思路
在这里插入图片描述
具体实现代码

package 算法.树.平衡二叉树;


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};
        AVLTree avlTree= new AVLTree();
        for (int i = 0; i <arr.length ; i++) {
            avlTree.add(new AVLTreeNode(arr[i]));
        }
        avlTree.midOrder();
        System.out.println(avlTree.getRoot().height());
        System.out.println(avlTree.getRoot().leftHeight());
        System.out.println(avlTree.getRoot().rightHeight());
    
    }
}

//创建AVLTree
class AVLTree {
    private AVLTreeNode root;



    //左旋方法


    //增加查找当前结点子树高度的方法
    //添加结点的方法
    public void add(AVLTreeNode node) {
        if (root == null) {
            root = node;
        } else {
            root.add(node);
        }
    }

    public AVLTreeNode getRoot() {
        return root;
    }

    //查找要删除的结点
    public AVLTreeNode search(int value) {
        if (root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }

    //查找要删除结点的父节点
    public AVLTreeNode searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }

    //删除结点
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            //找到要删除的结点
            AVLTreeNode targetNode = root.search(value);
            if (targetNode == null) {
                //没找到
                return;
            }
            //如果找到，但是根节点的左和右都为空，证明根节点就是要找的点，且只有一个根节点
            if (root.left == null && root.right == null) {
                root = null;
                return;
            }

            //根据三种情况开始判断。
            AVLTreeNode parentNode = root.searchParent(value);
            //第一种情况如果要删除的结点是叶子结点
            if (targetNode.left == null && targetNode.right == null) {
                //判断删除结点是父节点的左节点还是右结点
                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) {
                //先判断targetNode有两个子结点的情况，因为只有一个子节点的判断过于繁琐
                AVLTreeNode temp = targetNode.right;
                while (temp.left != null) {
                    temp = temp.left;//循环找到targetNode右子树的最小值
                }
                //删除targetNode右子树最小的结点(最小的结点要么只有右子树，要么没有子结点，符合另外两种情况)
                delNode(temp.value);
                //把temp中的数据赋给target
                targetNode.value = temp.value;

            } else {
                //删除的结点只有一个结点

                if (targetNode.left != null) {//删除结点的左子节点不空
                    //要考虑当targetNOde是根节点,没有父节点，且它只有一个子节点
                    if (parentNode != null) {//父节点不为空
                        if (parentNode.left != null && parentNode.left.value == targetNode.value) {
                            parentNode.left = targetNode.left;
                        } else {
                            parentNode.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }
                } else {//targetNode的右子节点不为空
                    if (parentNode != null) {
                        if (parentNode.left != null && parentNode.left.value == targetNode.value) {
                            parentNode.left = targetNode.right;
                        } else {
                            parentNode.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;
                    }

                }
            }
        }

    }

    //中序遍历,对二叉排序树进行中序遍历，刚好是顺序的
    public void midOrder() {
        if (root != null) {
            root.midOrder();
        } else {
            System.out.println("排序树为空");
        }
    }
}

class AVLTreeNode {
    int value;
    AVLTreeNode left;
    AVLTreeNode right;

    public AVLTreeNode(int value) {
        this.value = value;
    }
    //右旋的方法
    private void rightRotate(){
        AVLTreeNode newNode =  new AVLTreeNode(value);
        newNode.right=right;
        newNode.left=left.right;
        value=left.value;
        left=left.left;
        right=newNode;
    }

    //左旋的方法
    private void leftRotate(){
        //根据当前根节点的值创建一个新的结点
        AVLTreeNode newNode= new AVLTreeNode(value);
        //新结点的左子树指向根节点的左子树
        newNode.left=left;
        //新结点的右子树指向根节点的右子树的左子树
        newNode.right= this.right.left;
        //把当前根节点的值替换成它右子树的值
        this.value=right.value;
        //当前结点的右子树设置成右子树的右子树
        this.right=right.right;
        //当前结点的左子树指向新结点
        left= newNode;
    }

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

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

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

    //查找要删除结点的方法
    public AVLTreeNode search(int value) {
        if (this.value == value) {
            return this;
        } else if (value < this.value) {
            if (this.left == null) {
                return null;
            }
            return this.left.search(value);
        } else {//要查找的值不小于当前结点的value
            if (this.right == null) {
                return null;
            }
            return this.right.search(value);
        }
    }

    //查找要删除结点的父节点
    public AVLTreeNode searchParent(int value) {
        if ((this.left != null && this.left.value == value) ||
                (this.right != null && this.right.value == value)) {
            return this;
        } else {
            if (this.left != null && value < this.value) {
                return this.left.searchParent(value);
            } else if (this.right != null && value >= this.value) {
                return this.right.searchParent(value);

            } else {
                return null;//没有父节点
            }
        }

    }

    //添加结点的方法，要满足二叉排序树的要求
    public void add(AVLTreeNode node) {
        if (node == null) {
            return;
        }
        //判断传入的结点的值和根节点的关系
        if (node.value < this.value) {
            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){
            //如果根节点的右子节点的左子树高度大于右子树
            if(right.leftHeight()>rightHeight()){
                right.rightRotate();
            }
            this.leftHeight();
            return;//如果进行了一次左旋，就不进行右旋的判断了
        }
        if(leftHeight()-rightHeight()>1){
           //如果根节点的左子结点的右子树高度大于左子树
            if (left.rightHeight()>leftHeight()){
                //左子结点进行一次左旋
                left.leftRotate();
            }
            this.rightRotate();
        }
    }

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

    @Override
    public String toString() {
        return "AVLTreeNode{" +
                "value=" + value +
                '}';
    }
}
``
oldhunter686
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现平衡二叉树_平衡二叉树的Python实现
weixin_39849894的博客
12-16 817
本文参考了这篇文章链接二叉平衡树是一种时间复杂度为O(log n)的二叉查找树,其定义如下:所有叶子节点的高度差最大为1左节点比右节点要小每个节点上最多只能有2个子节点(left, right)二叉平衡树的性质如下:每个节点都有一个平衡因子(bf), 其值为左节点的高度减去右节点的高度,该数有效范围为[-1,1]最小非平衡子树:在新节点插入前,距离被插入节点最近的一个平衡因子为1或者-1的节点为根...
数据结构之平衡二叉树C语言版
Cukor丘克的博客
04-16 4550
作者：Cukor Zhong 什么是平衡二叉树 平衡二叉树是具有平衡属性的有序二叉树，所谓的平衡即当前树的左右子树高度差的绝对值不超过1。因为平衡二叉树是由苏联数学家Adelson-Velskii和Landis提出，所以又称为AVL树。 平衡二叉树的基本特点 是特殊的有序二叉树 左右子树高度差的绝对值不超过1 左右子树仍然是平衡二叉树
讲解平衡二叉树的实现（C语言）
weixin_62756978的博客
04-06 1138
讲解如何实现平衡二叉树的构造、增加节点、删除节点等操作。
平衡二叉树-C++实现
m0_55464171的博客
05-23 1085
目录前言：为什么需要平衡二叉树？二叉搜索树的局限性什么是平衡二叉树？平衡二叉树的递归定义平衡二叉树的功能平衡性调整：向上调整，4种方式右单旋左单旋LR双旋RL双旋插入：1种情况删除：3种情况求树的高度：后序遍历实现判断是否为平衡二叉树输出平衡二叉树的信息：中序遍历实现判断两棵AVL树是否相等平衡二叉树的赋值：防止内存泄漏清空：后序遍历，释放所有结点完整代码 前言：为什么需要平衡二叉树？ 二叉搜索树的局限性 相对于链表，二叉搜索树的静态查找具有高效性。但是，如果我们希望一棵二叉树既能实现查找操作，又能实现插入
使用Java实现平衡二叉树
qq_56323695的博客
05-28 1232
使用Java实现平衡二叉树 二叉树是一种较为复杂的数据结构,二叉树算法在数据查询时的时间复杂度为 O(log n)(n为保存元素个数). 但是普通的二叉树在数据添加和删除时很容易出现树结构不平衡问题 ,而使用平衡二叉树则不会出现这样的问题. 如何实现? 我们通过旋转完成 如:左旋转 怎么处理-进行左旋转 1.创建一个新的节点newnode(以4这个值创建)，创建一个新的节点，值等于当前根节点的值 //把新节点的左子树设置了当前节点的左子树 2.newnode.left=left //把新节点的右子树设置为当
平衡二叉树实现
卧龙小蛋的博客
12-27 347
实现平衡二叉树平衡二叉树概念平衡二叉树实现原理具体代码实现 平衡二叉树概念 在保持二叉树的基本原则外，任意结点左右子树高度差绝对值不超过1。 平衡二叉树实现原理 平衡二叉树相较于二叉搜索树会增加一个高度标识，用来标识每个结点的高度height，既而更方便的算出是否符合结点左右子树高度差balance绝对值小于等于1。每当插入一个结点，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树，...
平衡二叉树详解及C++实现
c661280411470yb的博客
06-08 748
平衡二叉搜索树
python实现平衡二叉树_LeetCode 110. 平衡二叉树 | Python
weixin_39794340的博客
02-10 188
# 110. 平衡二叉树---题目来源：力扣(LeetCode)[https://leetcode-cn.com/problems/balanced-binary-tree](https://leetcode-cn.com/problems/balanced-binary-tree)## 题目---给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 ...
C++实现平衡二叉树
ITSOK_123的博客
03-14 364
C++实现二叉树的平衡操作平衡二叉树实现准备工作节点结构体平衡二叉树类实现具体操作实现过程ll型（即插入节点在左子树的左子树上，对应右旋操作rr型（即插入节点在右子树的右子树上，对应左旋操作lr型（即插入节点在左子树的右子树上，对应先左旋再右旋操作rl型（即插入节点在右子树的左子树上，对应先左旋再右旋操作平衡函数实现 平衡二叉树实现准备工作 要实现二叉树，首先要对其节点和树结构进行定义； 节点结构体 `template<class T> struct Node { T key; Node&l
python实现平衡二叉树_代码实现平衡二叉树
weixin_40004502的博客
12-16 346
实现二叉树对于我们已经算是轻车熟路了。先来定义树的结点：class AVLNode {public int data;public int depth;public int balance;public AVLNode parent;public AVLNode left;public AVLNode right;public AVLNode(int data) {this.data = data...
平衡二叉树的实现实例
09-04
平衡二叉树是一种特殊的二叉树结构，它的特点是任何节点的两个子树的高度差不超过1，这确保了在平衡二叉树中查找、插入和删除操作的时间复杂度为O(log n)。平衡二叉树的主要类型包括AVL树和红黑树等。 在这个实现...
AVLTree 平衡二叉树c++实现
06-26
头文件定义了AVL树的结构和相关的成员函数声明，而源文件则包含了这些函数的具体实现。 **CAVLTree.h头文件**中可能会包含以下内容： 1. 定义AVL树节点结构体： ```cpp struct TreeNode { int key; int height...
广工数据结构实验——平衡二叉树
07-06
在这个实验中，`平衡二叉树数据结构实验.cpp`很可能是实现平衡二叉树（可能是AVL树或红黑树）的C++源代码。它可能包含了基本的二叉树操作（如插入、删除和查找）以及平衡调整算法的实现。源代码可以帮助我们理解如何...
二叉树和平衡二叉树的C#实现源码
03-02
对于压缩包中的"Algrithm-20160302"文件，它可能包含了这些二叉树和平衡二叉树的C#实现源代码，你可以通过解压并查看源码来学习和理解这些数据结构的具体实现细节。通过阅读和实践这些代码，你将能够更好地掌握...
平衡二叉树c++实现
03-30
在这个主题中，我们将深入探讨平衡二叉树的概念，特别是AVL树，以及如何用C++来实现这种数据结构。 首先，我们要理解什么是平衡因子。平衡因子是定义在一棵树的每个节点上的，它是该节点的左子树高度减去右子树高度...
【Hot100】LeetCode—31. 下一个排列
最新发布
weixin_44382896的博客
08-02 246
技巧题，分为以下几个步骤。
算法板子：BFS(广度优先搜索)——迷宫问题，求从迷宫的起点到终点的最短路径； 八数码问题，求从初始布局到最终布局x最少移动多少次
m0_67839004的博客
08-01 348
【代码】算法板子：BFS(广度优先搜索)——迷宫问题，求从迷宫的起点到终点的最短路径。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3493
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
【算法】退火算法 Simulated Annealing
藓类少女的博客
07-25 1472
退火算法（Simulated Annealing, SA）是一种基于热力学模拟的优化算法，用于求解全局优化问题。它通过模拟物理退火过程来寻找全局最优解。
平衡二叉树操作实现：插入、查找与删除
在课程设计中，学生需要实现这些操作，对平衡二叉树进行具体编程。这涉及理解二叉树的内部结构，如旋转操作（用于维持平衡），以及动态查找表的插入和删除算法。此外，还需要考虑如何有效地实现查找操作，以确保在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值