Java--平衡二叉树

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

Java–平衡二叉树–基于BST

二分搜索树：BST

文章目录

一、平衡二叉树性质

  • 左子树和右子树都是平衡二叉树；

  • 每一个节点的左右子树高度差的绝地值 <= 1

  • 平衡因子：左子树高度 - 右子树高度 在[-1,0,1]之间

二、底层实现

基于二分搜索树

三、节点类

每个节点都要维护自己所处的高度height

private class Node {
        public K key;
        public V value;
        public Node left, right;
        //每个节点还要维护自己所处的高度
        public int height;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            //新添加的叶子节点，高度为1
            height = 1;
        }
    }

在这里插入图片描述

import java.util.ArrayList;

/**
 * 平衡二叉树--基于二叉搜索树
 */
public class AVLTree<K extends Comparable<K>, V> {

    private class Node {
        public K key;
        public V value;
        public Node left, right;
        //每个节点还要维护自己所处的高度
        public int height;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            //新添加的叶子节点，高度为1
            height = 1;
        }
    }

    //根节点
    private Node root;
    //元素个数
    private int size;

    public AVLTree() {
        root = null;
        size = 0;
    }

    //返回该节点的高度
    private int getHeight(Node node) {
        if (node == null)
            return 0;
        return node.height;
    }

    //返回该节点的平衡因子=左右子树高度差
    private int getBanlanceFactor(Node node) {
        if (node == null)
            return 0;
        return getHeight(node.left) - getHeight(node.right);
    }

    //判断是否是一个二叉搜素树
    //中序遍历是一个从小到大的有序集
    private boolean isBST() {
        ArrayList<K> list = new ArrayList<>();
        inOrder(root, list);
        
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1).compareTo(list.get(i)) > 0)
                return false;
        }
        return true;
    }

    //中序遍历，并将结果存储到List中
    private void inOrder(Node node, ArrayList<K> list) {
        if (node == null)
            return;
        inOrder(node.left, list);
        list.add(node.key);
        inOrder(node.right, list);
    }

    //判断是否是一棵平衡二叉树
    private boolean isBalanced() {
        return isBalanced(root);
    }

    //递归遍历每个节点，查看平衡因子
    private boolean isBalanced(Node node) {
        //如果是空树依然维持平衡
        if (node == null)
            return true;

        //判断当前节点平衡因子
        if (Math.abs(getBanlanceFactor(node)) > 1)
            return false;
        
       	//当前节点的左右孩子也要平衡
        //遍历到叶子节点时，左右孩子为空，返回true
        return isBalanced(node.left) && isBalanced(node.right);
    }

	//元素个数
    public int getSize() {
        return size;
    }

    //判断树空
    public boolean isEmpty() {
        return size == 0;
    }
    
    public boolean contains(K key) {
        return getNode(root, key) != null;
    }
    
     // 返回以node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node, K key) {

        if (node == null)
            return null;

        if (key.equals(node.key))
            return node;
        else if (key.compareTo(node.key) < 0)
            return getNode(node.left, key);
        else // if(key.compareTo(node.key) > 0)
            return getNode(node.right, key);
    }
	
    //获取key对应的节点值
    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    public void set(K key, V newValue) {
        Node node = getNode(root, key);
        if (node == null)
            throw new IllegalArgumentException(key + " doesn't exist!");

        node.value = newValue;
    }


    //添加、删除-->维护平衡..
}
四、节点旋转
1）右旋转：LL
  • 旋转后依然是二分搜索树
  • 原因：添加节点后整棵树向左倾
    • y 的平衡因子大于1
    • x 的平衡因子 >= 0

在这里插入图片描述

	//整棵树向左倾斜--右旋转--->LL
    //对节点y进行向右旋转操作，返回旋转后新的根节点x
    public Node rightRotate(Node y) {
        Node x = y.left;

        y.left = x.right;
        x.right = y;

        //更新节点高度,先更新y,再更新x
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;

        return x;
    }

2）左旋转：RR
  • 原因：添加节点后整棵树向右倾
    • y 的平衡因子大于1
    • x 的平衡因子 <= 0

在这里插入图片描述

    //整棵树向右旋转--左旋转->RR
    //对节点y进行向左旋转操作，返回旋转后新的根节点x
    public Node leftRotate(Node y) {
        Node x = y.right;

        x.left = y;
        y.right = x.left;

        //更新节点高度,先更新y,再更新x
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;

        return x;
    }

3）LR

新添加元素 z 是被影响节点 y 左孩子的右孩子

x 左旋转前：T1 < x < T2 < z < T3 < y < T4

x 左旋转后：T1 < x < T2 < z < T3 < y < T4 ==>依然维持二分搜索树

  • 先对 x 左旋转—>整棵树左倾
  • 再对 y 进行右旋转即可

在这里插入图片描述

 	//LR类型
    //新添加的节点=x.right，造成了y的平衡因子>1
    //先对x进行左旋转，再对y进行右旋转
    //y.left = x
    public Node LR(Node y) {
        //对y左旋转后要用y.left接收变化，再对y右旋转
        y.left = leftRotate(y.left);
        return rightRotate(y);
    }

4）RL

新添加元素 z 是被影响节点 y 右孩子的左孩子

  • 先对 x 进行右旋转—>整棵树右倾
  • 再对 y 进行左旋转

在这里插入图片描述

 	//RL类型
    //新添加的节点=x.left,造成了y的平衡因子>1
    //先对x进行右旋转，再对y进行左旋转
    public Node RL(Node y) {
        y.right = rightRotate(y.right);
        return leftRotate(y);
    }

添加节点：

 	// 向二分搜索树中添加新的元素(key, value)
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    // 向以node为根的二分搜索树中插入元素(key, value)，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, K key, V value) {

        if (node == null) {
            size++;
            //添加到叶子节点，一定平衡
            return new Node(key, value);
        }
        if (key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if (key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0  【新值覆盖旧值】
            node.value = value;

        //添加完节点后，不断向上回溯检测node节点是否平衡
        //每一个节点高度=左右子树较高的高度+1
        //node的高度= max(Lheight,Rheight)+1
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));

        //查看当前节点的平衡因子
        int factor = getBanlanceFactor(node);

        //LL,右旋转---树左倾
        if (factor > 1 && getBanlanceFactor(node.left) >= 0)
            return rightRotate(node);

        //RR,左旋转---树右倾
        if (factor < -1 && getBanlanceFactor(node.right) <= 0)
            return leftRotate(node);

        //LR旋转
        if (factor > 1 && getBanlanceFactor(node.left) < 0)
            return LR(node);

        //RL旋转
        if (factor < -1 && getBanlanceFactor(node.right) > 0)
            return RL(node);

        return node;
    }

删除节点：

 // 返回以node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node) {
        if (node.left == null)
            return node;
        return minimum(node.left);
    }

    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node) {

        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }

        node.left = removeMin(node.left);
        return node;
    }

    // 从二分搜索树中删除键为key的节点
    public V remove(K key) {

        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        return null;
    }

    //删除一个节点后，可能会使当前根节点的平衡因子>1
    //需要对这个节点进行平衡维护
    private Node remove(Node node, K key) {

        if (node == null)
            return null;

        Node retNode;
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            retNode = node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            retNode = node;
        } else {   // key.compareTo(node.key) == 0
            // 待删除节点左子树为空-->删除最小值
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                retNode = rightNode;
            }
            // 待删除节点右子树为空-->删除最大值
            else if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                retNode = leftNode;
            } else {
                // 待删除节点左右子树均不为空

                // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
                // 用这个节点顶替待删除节点的位置
                Node successor = minimum(node.right);
                //维护
                successor.right = remove(node.right, successor.key);
                successor.left = node.left;

                node.left = node.right = null;
				//retNode:删除节点后，不断向上回溯的一个节点
                retNode = successor;
            }
        }

        //只有一个节点，被删除的情况
        if (retNode == null)
            return null;

        //删除节点后维护高度
        //node的高度= max(Lheight,Rheight)
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));

        //查看当前节点的平衡因子
        int factor = getBanlanceFactor(retNode);

        //判断平衡因子，右旋转
        //LL
        if (factor > 1 && getBanlanceFactor(retNode.left) >= 0)
            return rightRotate(retNode);

        //RR
        if (factor < -1 && getBanlanceFactor(retNode.right) <= 0)
            return leftRotate(retNode);

        //LR旋转
        if (factor > 1 && getBanlanceFactor(retNode.left) < 0) {
            retNode.left = leftRotate(retNode.left);
            return rightRotate(retNode);
        }

        //RL旋转
        if (factor < -1 && getBanlanceFactor(retNode.right) > 0) {
            retNode.right = rightRotate(retNode.right);
            return leftRotate(retNode);
        }

        return retNode;
    }
昫 灬
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java-平衡二叉树AVL的实现
04-23
在Java编程领域，平衡二叉树（特别是AVL树）是一种高效的数据结构，它通过保持树的高度平衡来确保查找、插入和删除操作的最优化。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962...
java-二叉树binaryTree
08-05
5. **平衡二叉树（Balanced Binary Trees）**：为了优化查找效率，有时我们需要保持二叉树的高度平衡，例如AVL树和红黑树。这类平衡二叉树在插入和删除操作后，会自动调整以保持平衡。 6. **二叉堆（Binary Heap）*...
【Java】二叉树
qq_61635026的博客
07-08 2193
二叉树（Binary Tree）是一种常见的树形结构，它由节点（Node）和节点之间的关系构成。每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树中的每个节点可以为空（null）。
Java语言----二叉树
tq02的博客
05-28 2869
二叉树详细讲解，以及Java实现代码
二叉树（Java版）
WYSCODER的博客
08-04 2881
二叉树，看这一篇就够了~~~
[数据结构]二叉树(JAVA)
weixin_53106294的博客
11-01 806
二叉树的基本概念及简单模拟实现
平衡二叉树(AVL)【java实现+图解】
weixin_63541561的博客
10-24 801
一种自平衡二叉搜索树，它是在每个节点上增加一个平衡因子，然后通过调整树中节点的高度来保持树的平衡。平衡因子是左子树的高度减去右子树的高度，用它可以表示出当前节点的平衡程度。删除：每删除一个节点后，也需要更新输的高度，平衡因子可能改变，依据平衡因子对二叉树进行调整。添加：每次添加一个节点后更新输的高度，平衡因子可能改变，依据平衡因子对二叉树进行调整；判断是否是平衡二叉树：通过判断每个子树的平衡因子的是否在[-1，1]区间内。，当一个节点的平衡因子绝对值大于1时，这个节点就被称为不平衡节点。
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
java-leetcode题解之第110题平衡二叉树.zip
最新发布
06-18
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第110题——“判断一棵二叉树是否是平衡二叉树”。平衡二叉树是一种特殊的二叉树结构，它的左右两个子树的高度差不超过1，并且左右两个子树都是一棵平衡...
java 实现平衡二叉树
11-23
文档中是我自己实现的用java语言实现(1)判断给定的二叉树是否平衡;（2）二叉树插入新数据后，如果失衡自我旋转调整的方法。
Java数据结构之二叉树
qq_64580912的博客
11-09 682
1) n个结点的二叉链表中含有n+1【公式2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索")2)这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种3)一个结点的前一个结点，称为前驱结点4)一个结点的后一个结点，称为后继结点。
数据结构（6）树形结构——平衡二叉树（JAVA代码实现）
Joker_ZJN的博客
11-28 1488
平衡二叉树的概念，平很二叉树的LL、RR、RL、LR旋转，以及JAVA版本的AVL树的实现。
二叉平衡树的调整
Mercury_Lc的博客
12-25 981
出自：http://www.cnblogs.com/lezhifang/p/6632355.html 说明：仅用于个人复习使用，如有侵权，立即删除 一：平衡二叉树的概念 平衡二叉树(Balanced binary tree)又称为AVL树，是一种特殊的二叉排序树，且左右子树的高度之差的绝对值不超过1. 定义：平衡二叉树或为空树,或为如下性质的二叉排序树: （1）左右子树深度之差的绝...
平衡二叉树（java代码实现）
m0_46400910的博客
01-07 889
平衡二叉树特点 平衡二叉树就是在二叉排序树的基础上保持`平衡`:**一颗空树**或**它的左右两个子树的高度差的绝对值不超过1**，并且**左右两子树都是一颗平衡二叉树** 平衡方法 在添加完成一个树节点后，则做判断进行调整，若不平衡，则做出以下处理 1. (右子树的高度-左子树的高度) > 1 再进行判断 ①如果**它的右子树的左子树的高度大于它的右子树的右子树的高度**，则**先对右子结点进行右旋转**，**然后再对当前结点进行左旋转** 左旋转右旋转
Java数据结构和算法---平衡二叉树
TIANJIAWEN的博客
04-05 1146
拿下大厂!
[Java]平衡二叉树的插入与删除
shichimiyasatone的博客
12-24 2078
平衡二叉树是一种特殊的排序二叉树（对于每个结点来说，左子树中所有结点的值 &lt; 结点值 &lt; 右子树中所有结点的值），树的左右结点高度（到叶子结点需要经过的最大结点数）差小于2。对一颗平衡二叉树进行中序遍历可以顺序输出所有节点的值，对树进行查找时类似二分查找，时间复杂度为log(n)。 一、排序二叉树 因为平衡二叉树是特殊的排序二叉树，所以在了解平衡二叉树前需要了解排序二叉树的增删。相...
JAVA实现平衡树
nvnnv的博客
03-05 709
复习，上代码package tree;/** * Created by rightHead on 2017/3/4. */ public abstract class BalanceTree<T> { private final class Node { T data; int equals; int deep; Node l
java实现二叉平衡树
fly_fly_fly_pig的博客
12-04 352
二叉平衡树定义 二叉树中所有子树的左右子树的高度差不超过1 树的高度 从所有叶节点开始数高度到根节点，其中的最大值即为树的高度 非平衡二叉树转成平衡二叉树(思路) 找出所有不平衡的子树,将不平衡子树的根节点记录下来. 调节位于最下方的子树,使之平衡 重复1,2步,直到这棵树平衡 每次调整只调整节点数最少的子树,节点少的子树大部分情况都为4中的基本情况 二叉树的调节(旋转)...
java平衡二叉树平衡因子
01-14
在Java中实现平衡二叉树时，可以通过计算每个节点的平衡因子来判断是否需要进行平衡操作。当插入或删除节点后，如果某个节点的平衡因子超过了1或小于-1，就需要进行相应的平衡操作，以保持树的平衡性。 以下是一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值