Java实现平衡二叉树代码

最新推荐文章于 2023-10-24 00:07:59 发布
最新推荐文章于 2023-10-24 00:07:59 发布
阅读量121 收藏
点赞数
分类专栏： 算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46136359/article/details/115257042
版权 
package datastructure;

import java.util.LinkedList;
import java.util.Queue;

public class AvlTree{
    private AvlNode root;
/**
 * 初始化平衡二叉树
 * @param val 键值
 */
public AvlTree(int val){
    this.root = new AvlNode(val);
}

public AvlTree(){
    this(1);
}

public AvlNode getRoot(){return root;}

private static class AvlNode{
    AvlNode parent;
    AvlNode left;
    AvlNode right;

    int val;

    public AvlNode(int val) {
        this.val = val;
    }
}

/**
 * 左子树过深，进行右旋操作
 * @param cur 失衡节点，平衡因子绝对值大于1的那个节点
 */
public void rightRotate(AvlNode cur){
    if(cur != null){
        //右旋有关的节点包括失衡节点本身，它的父节点，左孩子以及左孩子的右孩子
        AvlNode leftChild = cur.left;
        AvlNode parentNode = cur.parent;
        AvlNode rightGrandson = leftChild.right;

        //左孩子代替失衡节点位置
        leftChild.parent = parentNode;
        if(parentNode != null){
            if(parentNode.left == cur)
                parentNode.left = leftChild;
            else
                parentNode.right = leftChild;
        }else {
            //父节点为空则左孩子成为根节点
            this.root = leftChild;
        }
        //重新设置失衡节点和它的左孩子的指针指向
        leftChild.right = cur;
        cur.parent = leftChild;

        //失衡节点的左孩子的右子树 成为 失衡节点的左子树
        cur.left = rightGrandson;
        if(rightGrandson != null)
            rightGrandson.parent = cur;
    }
}

/**
 * 右子树过深，进行左旋操作
 * @param cur 失衡节点，平衡因子绝对值大于1的那个节点
 */
public void leftRotate(AvlNode cur){
    if(cur != null){
        //一次左旋涉及到的节点包括失衡节点本身，它的父节点，右孩子以及右孩子的左孩子
        AvlNode rightChild = cur.right;
        AvlNode parentNode = cur.parent;
        AvlNode leftGrandson = rightChild.left;

        //将失衡节点的右孩子的位置调整到失衡节点的位置
        rightChild.parent = parentNode;
        if(parentNode != null){
            if(parentNode.left == cur)
                parentNode.left = rightChild;
            else
                parentNode.right = rightChild;
        }else {
            this.root = rightChild;
        }
        //重现调整指向
        rightChild.left = cur;
        cur.parent = rightChild;

        //处理右孩子的左孩子
        cur.right = leftGrandson;
        if(leftGrandson != null)
            leftGrandson.parent = cur;
    }
}

/**
 * 获得当前节点的深度
 * @param cur 当前节点
 * @return 深度
 */
private int getDepth(AvlNode cur){
    if(cur == null)
        return 0;
    int left = getDepth(cur.left);
    int right = getDepth(cur.right);
    return left > right ? left + 1 : right + 1;
}

/**
 * 计算平衡因子
 * @param cur 节点
 * @return 平衡因子大小
 */
private int calBalance(AvlNode cur){
    if(cur == null)
        return 0;
    int leftDepth;
    int rightDepth;
    if(cur.left == null)
        leftDepth = 0;
    else
        leftDepth = getDepth(cur.left);
    if(cur.right == null)
        rightDepth = 0;
    else
        rightDepth = getDepth(cur.right);
    return leftDepth - rightDepth;
}

/**
 * 平衡二叉树新增节点
 * @param root 根节点
 * @param val 键值
 */
public void insert(AvlNode root, int val){
    //插入节点
    if(root.val > val){
        if(root.left != null)
            insert(root.left, val);
        else {
            root.left = new AvlNode(val);
            root.left.parent = root;
        }
    }else {
        if(root.right != null)
            insert(root.right, val);
        else {
            root.right = new AvlNode(val);
            root.right.parent = root;
        }
    }

    //调整二叉树
    rebuild(root);
}

public boolean delete(int val){
    boolean flag;//标识变量
    AvlNode temp = root;
    AvlNode delNode = null;//删除节点

    //找到删除节点的位置
    while (temp != null){
        if(temp.val == val){
            delNode = temp;
            break;
        }
        else if(temp.val > val)
            temp = temp.left;
        else
            temp = temp.right;
    }

    //删除节点后需要调整的节点位置
    AvlNode bal = null;
    
    if(delNode == null)
        return false;
    AvlNode parent = delNode.parent;
    boolean isLeft = true;
    if(parent != null && delNode == parent.right)
        isLeft = false;
    //删除节点为叶子节点
    if(delNode.left == null && delNode.right == null){
        //若不存在父节点，则删除节点为根节点
        if(parent == null)
            root = null;
        else {
            if(isLeft)
                parent.left = null;
            else
                parent.right = null;
        }
        bal = parent;
        delNode = null;
        flag = true;
    }//删除节点有一个孩子节点
    else if((delNode.left != null && delNode.right == null) || (delNode.left == null && delNode.right != null)){
        if(delNode.left != null){
            if(parent == null){
                root = delNode.left;
            } else {
                if(isLeft)
                    parent.left = delNode.left;
                else
                    parent.right = delNode.left;
            }
            delNode.left.parent = parent;
        }
        if(delNode.right != null){
            if(parent == null){
                root = delNode.right;
            }else {
                if(isLeft)
                    parent.left = delNode.right;
                else
                    parent.right = delNode.right;
            }
            delNode.right.parent = parent;
        }
        bal = parent;
        delNode = null;
        flag = true;
    }//删除节点左右孩子都不为空，找到直接后继节点，删除此节点，将它的值赋给删除节点即可
    else {
        //获得直接后继节点
        AvlNode processor = getDirectPostNode(delNode);
        int tempVal = processor.val;
        boolean delete = delete(tempVal);
        if(delete){
            delNode.val = tempVal;
        }
        bal = processor;
        processor = null;
        flag = true;
    }

    //对二叉树进行再调整
    if(flag)
        rebuild(bal);

    return flag;
}

/**
 * 重新调整二叉树
 * @param root 新插入节点的父亲节点
 */
private void rebuild(AvlNode root){
    //向上回溯找到最近可能破坏平衡的节点
    while (root != null){
        int balance = calBalance(root);//此时root指向插入节点的父节点

        //左子树高，准备右旋
        if(balance > 1){
            //此时右孙较深，先左旋
            if(calBalance(root.left) == -1) {
                leftRotate(root.left);
            }
            rightRotate(root)；
        }

        //右子树高，准备左旋
        if(balance < -1){
            //此时左孙较深，应先右旋调整
            if(calBalance(root.right) == 1) {
                rightRotate(root.right);
            }
            leftRotate(root);
        }
        root = root.parent;
    }
}
/**
 * 获得直接后继节点
 * @param cur 当前节点
 * @return 直接后继节点
 */
private AvlNode getDirectPostNode(AvlNode cur){
    //当前节点的右子树不为空，则直接后继节点一定存在右子树上
    if(cur.right != null){
        AvlNode right = cur.right;
        while (right.left != null){
            right = right.left;
        }
        return right;
    }
    //当前节点的右子树为空，若当前节点是父亲节点的左孩子，则
    //父亲节点是它的直接后继节点，若当前节点是父亲节点的右孩子，则
    //一直向上回溯到它的某个祖先节点是某个节点的左子树即可
    AvlNode parent = cur.parent;
    while (parent != null && (cur == parent.right)){
        cur = parent;
        parent = parent.parent;
    }
    return parent;
}

/**
 * 依次打印每一层节点
 */
public void travel(){
    Queue<AvlNode> queue = new LinkedList<>();
    queue.offer(this.root);
    int i = 1;
    while (!queue.isEmpty()){
        System.out.println("这是二叉树第" + i + "层");
        int count = 0;
        int size = queue.size();
        while (count < size && !queue.isEmpty()){
            AvlNode out = queue.poll();
            System.out.print(out.val + " ");
            if(out.left != null)
                queue.offer(out.left);
            if(out.right != null)
                queue.offer(out.right);
            count++;
        }
        i++;
        System.out.println();
    }
}

/**
 * 中序遍历二叉树
 * @param root 根节点
 */
public void inOrder(AvlNode root){
    if(root != null){
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }
}

//测试主函数
public static void main(String[] args) {
    AvlTree avlTree = new AvlTree(1);
    avlTree.insert(avlTree.getRoot(), 2);
    avlTree.insert(avlTree.getRoot(), 5);
    avlTree.insert(avlTree.getRoot(), 3);
    avlTree.insert(avlTree.getRoot(), 6);
    avlTree.insert(avlTree.getRoot(), 4);
    avlTree.insert(avlTree.getRoot(), 7);
    System.out.println("----------------------");
    avlTree.travel();
    avlTree.inOrder(avlTree.getRoot());
    avlTree.delete(3);
    System.out.println("----------------------");
    avlTree.travel();
    avlTree.inOrder(avlTree.getRoot());
}

}

菲菲菲菲常美丽12138
关注
专栏目录
平衡二叉树【Java实现】
qq_45702990的博客
08-16 436
平衡二叉树的左旋转、右旋转、双旋转实现
java实现平衡二叉树
qq_45731129的博客
08-31 951
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树，可以保证查询效率较高。具有以下特点: 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。举例说明, 看看下面哪些AVL树,为什么?平衡二叉搜索树的左右子树，高度差不能大于1，所以前两个满足。...
Java实现平衡二叉树（仅含代码）
qq_41040289的博客
08-15 424
代码实现 package datastructure; import java.util.LinkedList; import java.util.Queue; public class AvlTree{ private AvlNode root; /** * 初始化平衡二叉树 * @param val 键值 */ public AvlT...
平衡二叉树java代码实现
zhongjiangYT的博客
09-09 275
平衡二叉树java代码实现 实现以下功能： 创建二叉排序树 添加结点，包含左旋，右旋，双旋转添加 查找结点 删除结点 已将各功能进行排序标号整理，防止过于杂乱。 /** * 平衡二叉树 * * @author 韩帅比 * @create 2021-09-09 17:35 */ public class AVLTreeDemo { public static void main(String[] args) { int[] arr = {10,11,7,6,8,9};
【Java】平衡二叉树的实现代码
weixin_63434588的博客
06-26 279
平衡二叉搜索树（英语：Balanced Binary Tree）是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
java 平衡二叉树代码
miss_na的博客
04-23 120
说明：java使用的是值传递，如果处理不好，容易出现空指针异常 public class AVL { public AVL() { } // 插入应该一直往右边插 public Node insert(int e, Node root) { // 也就是说root在传入前必须有指向的对象 if (root == null) { root = new Node(e); return root;
平衡二叉树的java实现
Cocos2d-X入门教程
07-19 888
平衡二叉树求解步骤： （1）插入节点 （2）找出不平衡因子，在插入过程中找到不平衡因子 （3）旋转，根据不平衡因子判断旋转方式 （4）生成新的平衡二叉树 在求解过程中，最重要步骤详解： 找出不平衡因子（也就是左右子树的高度差值为2或-2的情况） 方法1步骤： a.节点中添加两个属性，左子树高度、右子树高度。 b.插入节点 c.返回的过程中动态的计
使用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年提出，因此...
平衡二叉树详解及java代码的实现
01-19
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树（递归定义）的二叉排序树。...
【数据结构】平衡二叉树java代码实现 构建平衡二叉树-单旋转/双旋转
y159_4的博客
02-26 220
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....
java平衡二叉树(AVL)代码
m0_50262736的博客
02-18 410
package avl; public class AVLTreeDemo { public static void main(String[] args) { // TODO Auto-generated method stub // int arr[]= {4,3,6,5,7,8}; //int arr[] = { 10, 12, 8, 9, 7, 6 }; int []arr= {10,11,7,6,8,9}; ...
平衡二叉树（java代码实现）
m0_46400910的博客
01-07 901
平衡二叉树特点 平衡二叉树就是在二叉排序树的基础上保持`平衡`:**一颗空树**或**它的左右两个子树的高度差的绝对值不超过1**，并且**左右两子树都是一颗平衡二叉树** 平衡方法 在添加完成一个树节点后，则做判断进行调整，若不平衡，则做出以下处理 1. (右子树的高度-左子树的高度) > 1 再进行判断 ①如果**它的右子树的左子树的高度大于它的右子树的右子树的高度**，则**先对右子结点进行右旋转**，**然后再对当前结点进行左旋转** 左旋转右旋转
数据结构——平衡二叉树（Java代码实现）
共勉
05-25 947
当对一个数组[1,2,3,4,5,6,]创建排序二叉树的时候看起来更像是一个链表，这个时候就需要使用到平衡二叉树。 基本介绍 平衡二叉树也叫平衡二叉搜索树(Self-balancing binarysearchtree)又被称为AVL树，可以保证查询效率较高。 具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、 伸展树等。 二叉排序树和平衡二叉树的转化 进行左旋转. 创建一个新的节
JAVA代码实现平衡二叉树
qq_41665523的博客
03-22 1222
平衡二叉树 平衡二叉树又叫AVL树，它是在二叉排序树的基础上进行了树结构的调整，使其根节点的左右子树的高度差一致。可以保证查询效率更加高效。 平衡二叉树涉及到左旋转、右旋转和双旋转，接下来分别用图解分析一下： 左旋转 右旋转 双旋转 代码如下： package com.avl; /* * 平衡二叉树： * 1.左旋转 * 2.右旋转 * 3.双旋转 */ public class...
数据结构（6）树形结构——平衡二叉树（JAVA代码实现）
Joker_ZJN的博客
11-28 1509
平衡二叉树的概念，平很二叉树的LL、RR、RL、LR旋转，以及JAVA版本的AVL树的实现。
平衡二叉树(附Java实现源码)
Ekertree的博客
07-15 583
右旋转 平衡二叉树的添加 步骤 如果要添加的结点为空直接退出方法 判断传入的结点的值与当前子树的根结点的关系 要添加的结点的值小于当前结点的值 若当前结点的左子结点为空,则将该结点设置为当前结点的左子结点 若当前结点的左子结点不为空,递归向左子树添加 要添加的结点的值大于当前结点 若当前结点的右子结点为空,则将该结点设置为当前结点的右子结点 若当前结点的右子结点不为空,递归向右子树添加 添加完成后,在每一层子树都进行判断 如果右子树的高度-左子树的高度 > 1 则进行左旋转 如果当前结
平衡二叉树-java代码实现
dengjili的专栏
01-19 428
资料引入说明 平衡二叉树理论知识参考：https://blog.csdn.net/dengjili/article/details/111463328 二叉排序树理论知识参考：https://blog.csdn.net/dengjili/article/details/111503799 二叉排序树-java代码实现:https://blog.csdn.net/dengjili/article/details/111992147 平衡二叉树是在二叉排序树代码基础上进行平衡的，这里直接使用了二
平衡二叉树(AVL)【java实现+图解】
weixin_63541561的博客
10-24 1018
一种自平衡二叉搜索树，它是在每个节点上增加一个平衡因子，然后通过调整树中节点的高度来保持树的平衡。平衡因子是左子树的高度减去右子树的高度，用它可以表示出当前节点的平衡程度。删除：每删除一个节点后，也需要更新输的高度，平衡因子可能改变，依据平衡因子对二叉树进行调整。添加：每次添加一个节点后更新输的高度，平衡因子可能改变，依据平衡因子对二叉树进行调整；判断是否是平衡二叉树：通过判断每个子树的平衡因子的是否在[-1，1]区间内。，当一个节点的平衡因子绝对值大于1时，这个节点就被称为不平衡节点。
java平衡二叉树代码
05-19
下面是一个简单的Java平衡二叉树实现示例： ``` import java.util.*; public class RedBlackTree, V> { private static final boolean RED = true; private static final boolean BLACK = false; private ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值