Java 树结构实际应用 四（平衡二叉树/AVL树）

最新推荐文章于 2023-02-08 17:34:26 发布
最新推荐文章于 2023-02-08 17:34:26 发布
阅读量84 收藏
点赞数
原文链接：https://www.cnblogs.com/linzm14/p/14543850.html
版权

3)代码实现

复制代码
// 左旋转
private void leftRotate() {
// 创建新的节点，以当前根节点的值
SNode newNode = new SNode(value);
// 把新的节点左子树设置成当前节点的左子树
newNode.left = left;
// 把新节点的右子树设置成当前节点的右子节点的左子树
newNode.right = right.left;
// 把当前节点的值换为右子节点的值
value = right.value;
// 把当前节点的右子树换成右子树的右子树
right = right.right;
// 把当前节点的左子树设置成新节点
left = newNode;

}

复制代码

4 应用案例-单旋转(右旋转)

  1. 要求: 给你一个数列，创建出对应的平衡二叉树.数列 {10,12, 8, 9, 7, 6}
  2. 思路分析(示意图)

3)代码实现

复制代码
// 右旋转
private void rightRotate() {
SNode newNode = new SNode(value);
newNode.right = right;
newNode.left = left.right;
value = left.value;
left = left.left;
right = newNode;

}

复制代码

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

  1. 问题分析

  2. 解决思路分析

  1. 当符号右旋转的条件时
  2. 如果它的左子树的右子树高度大于它的左子树的高度
  3. 先对当前这个结点的左节点进行左旋转
  4. 在对当前结点进行右旋转的操作即可
  1. 代码实现[AVL 树的汇总代码(完整代码)]
    复制代码
    package com.lin.avltree_0316;

import javax.security.auth.kerberos.KerberosKey;

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 = new AVLTree();
    for (int i = 0; i < arr.length; i++) {
        avlTree.add(new SNode(arr[i]));
    }
    
    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("root = " + avlTree.getRoot());
    System.out.println("root.left = " + avlTree.getRoot().left);
    System.out.println("root.left.left = " + avlTree.getRoot().left.left);
}

}

class AVLTree{
private SNode root;
// 查找要删除的节点
public SNode getRoot() {
return root;
}
public SNode searchDelNode(int value) {
if(root == null) {
return null;
} else {
return root.searchDelNode(value);
}
}
// 查找要删除节点的父节点
public SNode searchParent(int value) {
if(root == null) {
return null;
} else {
return root.searchParent(value);
}
}
/**
* @param node 传入的节点（当作二叉排序树的根节点）
* @return 返回的以node为根节点的二叉排序树的最小节点的值
*/
public int delRightTreeMin(SNode node) {
SNode target = node;
// 循环地查找左节点，就会找到最小值
while(target.left != null) {
target = target.left;
}
delNode(target.value);// !!!
return target.value;// !!!
}

// 删除节点
public void delNode(int value) {
    if(root == null) {
        return;
    } else {
        //     找删除节点
        SNode targetNode = searchDelNode(value);
        //     没有找到
        if(targetNode == null) {
            return;
        }
        //    如果发现当前这棵二叉树只有一个节点
        if(root.left == null && root.right == null) {
            root = null;
            return;
        }
        //     去找到targetNode的父节点
        SNode parent = searchParent(value);
        //     如果删除的节点是叶子节点
        if(targetNode.left == null && targetNode.right == null) {
            //    判断targetNode是父节点的左子节点还是右子节点
            if(parent.left != null && parent.left.value == value) {
                parent.left = null;
            } else if(parent.right != null && parent.right.value == value) {
                parent.right = null;
            }
        } else if(targetNode.left != null && targetNode.right != null) { //    有左右子节点
            int delRightTreeMin = delRightTreeMin(targetNode.right);
            targetNode.value = delRightTreeMin;
        } else {//    只有一个子节点
            //     要删除的节点只有左节点
            if(targetNode.left !=  null) {
                if(parent != null) {
                    //     如果targetNode是parent的左子节点
                    if(parent.left.value == value) {
                        parent.left = targetNode.left;
                    } else {
                        parent.right = targetNode.left;
                    }
                } else {
                    root = targetNode.left;
                }
            } else {//    要删除的节点有右子节点
                if(parent != null) {
                    if(parent.left.value == value) {
                        parent.left = targetNode.right;
                    } else {
                        parent.right = targetNode.right;
                    }
                } else {
                    root = targetNode.right;
                }
            }
        }
        
        
    }
}
// 中序遍历
public void infixOrder() {
    if(root == null) {
        System.out.println("空树！");
    } else {
        root.infixOrder();
    }
}
// 添加
public void add(SNode node) {
    if(root == null) {
        root = node;
    } else {
        root.add(node);
    }
}

}

class SNode{
protected int value;
protected SNode left;
protected SNode right;

public SNode(int value) {
    // TODO Auto-generated constructor stub
    this.value = value;
}
// 返回左子树的高度
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() {
    // 创建新的节点，以当前根节点的值
    SNode newNode = new SNode(value);
    // 把新的节点左子树设置成当前节点的左子树
    newNode.left = left;
    // 把新节点的右子树设置成当前节点的右子节点的左子树
    newNode.right = right.left;
    //    把当前节点的值换为右子节点的值
    value = right.value;
    // 把当前节点的右子树换成右子树的右子树
    right = right.right;
    // 把当前节点的左子树设置成新节点
    left = newNode;
    
}

// 右旋转
private void rightRotate() {
    SNode newNode = new SNode(value);
    newNode.right = right;
    newNode.left = left.right;
    value = left.value;
    left = left.left;
    right = newNode;
    
}

@Override
public String toString() {
    // TODO Auto-generated method stub
    return "Node = [value = " + value + "]";
}

// 添加节点
public void add(SNode 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 != null && (right.leftHeight() > rightHeight() ) ) {
            right.rightRotate();
            leftRotate();
        } else {
            leftRotate();
        }
        return;//!!!!
    }
    
    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 SNode searchDelNode(int value) {
    if(this.value == value) {
        return this;
    } else if(this.value > value) {
        // 如果左子节点为空
        if(this.left == null) {
            return null;
        }
        return this.left.searchDelNode(value);
    } else {
        if(this.right == null) {
            return null;
        }
        return this.right.searchDelNode(value);
    }
}
// 查找要删除节点的父节点, 如果没有则返回null
public SNode 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;
        }
    }
}

}
亚马逊测评 www.yisuping.cn

USB Microphone https://www.soft-voice.com/

Wooden Speakers https://www.zeshuiplatform.com/

福伴
关注
平衡二叉树（AVLTree）详解
土豆的博客
07-06 1677
一、平衡二叉树：            这几天学了平衡二叉树，对于平衡二叉树，我觉得开始在理解插入旋转以及其平衡因子的调整时有点吃力。如今理清就来谈谈这部分。     对于平衡二叉树的理解：                平衡二叉树又称AVL树，（有别于AVL算法）,且具有以下性质：                它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都
树结构实际应用(平衡二叉树，AVL 树)
笔记别偷看
11-05 840
看一个案例(说明二叉排序树可能的问题) 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在.  左边BST 存在的问题分析: 左子树全部为空，从形式上看，更像一个单链表. 插入速度没有影响 查询速度明显降低(因为需要依次比较), 不能发挥BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢 解决方案-平衡二叉树(AVL) 基本介绍 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL 树，
Java树结构实际应用（平衡二叉树/AVL树），讲得透透的
weixin_51954021的博客
03-16 352
1、 看一个案例(说明二叉排序树可能的问题) 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在.  左边 BST 存在的问题分析: 1) 左子树全部为空，从形式上看，更像一个单链表. 2) 插入速度没有影响 3) 查询速度明显降低(因为需要依次比较), 不能发挥 BST 的优势，因为每次还需要比较左子树，其查询速度比 单链表还慢 4) 解决方案-平衡二叉树(AVL) 2、 基本介绍 1) 平衡二叉树也叫平衡二叉搜索树（Self-balancin
Java树结构应用
！不将就的博客
02-13 361
树结构应用 一、堆排序 1. 概述 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度均为O(logn)，它也是不稳定排序 堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右节点的值，称为大顶堆，**注意：**没有要求左右孩子值的大小关系 每个节点的值都小于或等于其左右孩子的值，称为小顶堆 大顶堆举例： 一般升序采用大顶堆，降序采...
java树结构实际应用
最新发布
papillonlong的博客
02-08 470
4) 这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中 6 最大，交换 4 和 6。3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，要求：给你一个数组 {4,6,8,5,9} , 要求使用堆排序法，将数组升序排序。要求：给你一个数组 {4,6,8,5,9} , 要求使用堆排序法，将数组升序排序。3) .再将堆顶元素 8 与末尾元素 5进行交换，得到第二大元素 8.4) 后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序。
Java树型数据结构的应用
qq_963157144的博客
04-17 283
AVL树: 最早的平衡二叉树之一。应用相对其他数据结构比较少。windows对进程地址空间的管理用到了AVL树。 红黑树: 平衡二叉树，广泛用在C++的STL中。如map和set都是用红黑树实现的。 B/B+树: 用在磁盘文件组织 数据索引和数据库索引。 Trie树(字典树): 用在统计和排序大量字符串，如自动机。 哈夫曼树：哈夫曼编码是哈夫曼树的一个应用。在数字通...
java数据结构与算法之平衡二叉树(AVL树)的设计与实现分析.pdf
12-08
平衡二叉树（AVL树）是数据结构与算法领域中的一个重要概念，它是一种自平衡的二叉查找树。在AVL树中，任何节点的两个子树的高度差最多为1，这确保了树的平衡性，从而保证了在最佳情况下操作的时间复杂度为O(log n)...
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
AVL树的旋转有四种类型：左旋、右旋、左-右旋和右-左旋，这些旋转用于重新调整树的结构，使其保持平衡。 2. 删除：删除节点同样可能导致不平衡。删除操作可能需要与插入操作类似的旋转来恢复平衡。处理删除节点的...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡...通过了解AVL树的定义、实现和使用技巧，可以更好地应用于实际项目中。
Java与数据结构——树的应用（赫夫曼树）
u012621831的博客
08-12 300
若规定根节点的层数为 1 ，则从根节点到第 L 层节点的路径长度为 L-1；节点的带权路径长度为：从根节点到该节点之间的路径长度与该节点的权的乘积。（5）树的带权路径长度：树的带权路径长度规定为所有叶子节点的带权路径长度之和，记为 WPL，权值越大的节点离根节点越近的二叉树才是最优二叉树。（4）再将这棵新的二叉树，以根节点的权值大小再次排序，不断重复 1~4 的步骤，直到数列中所有的数据都被处理，就得到了一棵赫夫曼树。（3）组成一棵新的二叉树，该新的二叉树的根节点的权值是前面两棵二叉树根节点权值的和；...
平衡二叉树（AVL Tree）
asdv78901的博客
08-31 227
在学习算法的过程中，二叉平衡树是一定会碰到的，这篇博文尽可能简明易懂的介绍下二叉树的相关概念，然后着重讲下什么事平衡二叉树。 （由于作图的时候忽略了箭头的问题，正常的树一般没有箭头，虽然不影响描述的过程，但是还是需要注意，所以还请读者忽略一下部分图的箭头） 一、二叉（查找）树 二叉查找树（Binary Search Tree）是二叉树的一种，其树节点（internal nodes ...
java树结构的应用_Java数据结构与算法 day10 树结构实际应用(三)
weixin_36199877的博客
02-26 87
第10章 树结构的实际应用本章源码：https://github.com/name365/Java-Data-structure二叉排序树二叉排序树(BST)的介绍先看一个需求：给你一个数列 (7, 3, 10, 12, 5, 1, 9)，要求能够高效的完成对数据的查询和添加。解决方案分析：使用数组数组未排序， 优点：直接在数组尾添加，速度快。 缺点：查找速度慢.数组排序，优点：可以使用二分查找，...
java树结构的应用_Java数据结构与算法 day08 树结构实际应用(一)
weixin_42348394的博客
02-26 178
第10章 树结构实际应用本章源码：https://github.com/name365/Java-Data-structure堆排序大顶堆和小顶堆图解说明堆排序基本介绍1.堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。2.堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆...
Java-平衡二叉树
Subuprogrammer的博客
07-19 160
一、平衡二叉树 对于树中的任何一个节点，它的左子树和右子树的高度差不超过1 那么，这里就有两个方面考虑： 1、怎样求子树的高度 2、如何判断是否平衡？ 这里，使用递归来实现 public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } }*/ public cl
利用java实现平衡二叉树
qq_52247089的博客
04-24 533
平衡二叉树是一种特殊的二叉查找树，而二叉查找树又是一种特殊的二叉树，也就是说他们之间的继承关系是： 平衡二叉树 -> 二叉查找树 -> 二叉树 故而我们用来实现平衡二叉树所使用的方式是面向对象地，分步地，利用继承关系分别建立这三种类，而不是直接建立一个平衡二叉树。 一、 第一步，建立抽象类Tree，其内部提供一个静态内部类Node，作为树的节点，并实例化一些方法，例如打印树（先序遍历，中序遍历，后序遍历都有），还有树的构造器方法，将从某节点的子孙节点插入和移除某个元素的方法设置为抽象的。代码
JAVA实践自平衡二叉树（AVL树）
薛定谔的猫窝
08-15 1698
前言平衡二叉树是二叉搜索树的一个变种，一棵完全偏向一边的搜索树在一定程度上会影响查找性能。 然而历史上总是不缺神，一些追求极致、完美（强迫症）的神就想出了平衡二叉树。本次仅实现插入、按层级展示两个功能。安利 此文很不错，特别是自带动画效果！！ http://blog.csdn.net/eson_15/article/details/51144079这个简明扼要！！！ http://www.c
平衡二叉树(AVLTree)
艰难困苦如同欢乐，终将成为人生最后的财富
03-20 824
平衡二叉树（AVLTree）是指带平衡条件的二叉查找树。AVLTree要求每个节点的左子树和右子树的高度之差最多为1。当因为插入或删除操作导致AVLTree不满足该平衡条件时就需要进行调整操作，包括单旋转和双旋转操作。也正是因为需要时刻保持树的平衡条件，从而使得AVLTree的插入和删除操作较为复杂。
平衡二叉树（AVLTREE）
m0_63222000的博客
07-02 245
二叉搜索树的查找、插入、删除性能的时间复杂度均为Ologn但这是在期望的前提下，在最好和最坏的前提下差别较大。在最好情况下，二叉查找树的形态和二分查找的判定相似，每次可以缩小一半的查找范围。但是在最坏的情况下，二叉查找树为单支树，即只有从左子树到右子树，每次查找的搜索范围为n-1，退化为顺序查找。二叉查找树的效率和树高成反比，那么为了提高二叉查找树的效率这里就引入了平衡二叉树。平衡二叉查找树即平衡二叉树具有以下性质： 1：平衡二叉树可以为空树。 2：左右子树的高度差值的绝对值不超过1
平衡二叉树与AVL树：高级数据结构解析
课程主要涉及平衡二叉树、可并优先队列、线段树和树状数组基础，以及RMQ与LCA等重要概念。" 在计算机科学中，数据结构是算法设计和分析的关键，尤其对于解决复杂问题至关重要。本课程深入探讨了几个重要的高级数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值