java实现二叉平衡树

最新推荐文章于 2022-12-25 14:58:58 发布
原创 最新推荐文章于 2022-12-25 14:58:58 发布 · 436 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #平衡二叉树

本文深入探讨了二叉平衡树的定义，不平衡二叉树转为平衡二叉树的策略，以及通过旋转调整树平衡的具体算法。介绍了树高度的概念，不平衡子树的查找和调整方法，特别是针对不同不平衡情况的旋转处理，包括单旋转和双旋转，以及如何在算法设计中避免常见错误。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. 二叉平衡树定义
    二叉树中所有子树的左右子树的高度差不超过1

  2. 树的高度
    从所有叶节点开始数高度到根节点，其中的最大值即为树的高度

  3. 非平衡二叉树转成平衡二叉树(思路)

  1. 找出所有不平衡的子树,将不平衡子树的根节点记录下来.
  2. 调节位于最下方的子树,使之平衡
  3. 重复1,2步,直到这棵树平衡
    每次调整只调整节点数最少的子树,节点少的子树大部分情况都为4中的基本情况
  1. 二叉树的调节(旋转)
    不平衡的情况(符合二叉树的规则大的节点在右边,小的在左)
    图一
    在这里插入图片描述
    图二
    在这里插入图片描述

图一中
1,2两种情况,分别以中间的节点为旋转中心顺时针(1),逆时针(2)将根节点旋转到中间节点的下方.(两种情况对应)
3,4两种情况,将最下方的节点作为根节点,分别将根节点,中间节点作为最下方节点的左右子节点.(两种情况对应)
处理图:(四种情况中列出两种,其余两种对应)
在这里插入图片描述

图二中
1(ll),2(rr)两种情况,分别以根节点的左子节点(1),右子节点(2)为旋转中心,将跟节点选装至他子节点的下方,子节点的右(左)子节点,称为根节点的左(右)子节点.(两种情况对应)

3(lr),4(rl)两种情况,以最下方的叶子节点的父节点为旋转中心,将跟节点的左(右)子节点旋转至其父节点的下方,这样3,4两种情况就转化成了1,2两种情况,再用处理1,2两种情况的方法处理.(两种情况对应)
处理图:(四种情况中列出两种,其余两种对应)在这里插入图片描述

其余情况:最小的不平衡子树的高度超过4
在这里插入图片描述

只需将根节点旋转至节点少的这一侧即可

  1. 算法设计及实现

了解了大致情况,要转换成二叉树,节点的变换,
(1)左右节点变化(是否从有到无或者从无到有),过程中很可能忘记setRight(null)操作,这样这棵树就完全乱了.我的User类中在设置左右节点时,就将左右节点的父节点设置成当前节点

public void setLeft(User faust) {
		
		this.left = faust;
		if(faust != null)
			faust.head = this;
		
	}

	public void setRight(User pippin) {
		
		this.right = pippin;
		if(pippin != null)
			pippin.head = this;
	}

(2)根节点是否改变,根节点没有父节点要setHead(null); root = user;这两步操作

计算树的高度

public int getDepth(User treeRoot){
		
		if(treeRoot == null)
			return 0;
		
		return Math.max(getDepth(treeRoot.getLeft()), getDepth(treeRoot.getRight()))+1;
		
	}

判断是否为平衡二叉树

ArrayList<User> avlUsers = new ArrayList<User>();
int l;//每次记录的是最后一次判断的子树的根
public boolean isAvl(User treeRoot){
		if(treeRoot == null)
			return true;
		if(Math.abs(getDepth(treeRoot.getLeft())-getDepth(treeRoot.getRight()))>1){
			avlUsers.add(treeRoot);//记录不平衡子树的根节点
			if(getDepth(treeRoot.getLeft())>getDepth(treeRoot.getRight()))
				l = 1;//左边子树高导致的不平衡
			else {
				l = 0;//右边子高导致的不平衡
			}
			return false;
		}
		else 
			return isAvl(treeRoot.getLeft())&&isAvl(treeRoot.getRight());//左右子树都平衡,这棵树才平衡
	}

调节算法

public void toAVL(User user){
		
		User insertUser = user.getHead();
		User insertUserHead = insertUser.getHead();
		
		
		if(insertUserHead.getRight() == null || insertUserHead.getLeft()==null){//单转
			treeRoate(user, insertUser, insertUserHead);
			
		}else {
			User p = insertUserHead.getHead();
			int g = getDepth(avlUsers.get(avlUsers.size()-1));
			if (g<5) {
				if(insertUserHead == p.getLeft() && insertUser == insertUserHead.getRight()){//图二中的3，lr
					
					//先单转
					treeRoate(user, insertUser, insertUserHead);
					
					treeRoateLL(p.getLeft().getLeft(), p.getLeft());
				}
				
				else if(insertUserHead == p.getRight() && insertUser == insertUserHead.getLeft()){//图二中的4，rl
					//先单转
					treeRoate(user, insertUser, insertUserHead);
					
					treeRoateLL(p.getRight().getRight(), p.getRight());
				}
			}else//图二中的1，2情况，其余情况
				treeRoateLL(insertUser, insertUserHead);
		}
	}

图一中情况处理

public void treeRoate(User user,User insertUser,User insertUserHead){
		if(user==insertUser.getRight()&&insertUser == insertUserHead.getRight()){//rr
			
			if(insertUserHead == root){
				insertUser.setHead(null);
				root = insertUser;
				insertUser.setLeft(insertUserHead);
				insertUserHead.setRight(null);
			}else {
				User p = insertUserHead.getHead();
				if(p.getLeft() == insertUserHead)
					p.setLeft(insertUser);
				else
					p.setRight(insertUser);
				insertUser.setLeft(insertUserHead);
				insertUserHead.setRight(null);
			}
		}
		else if(user==insertUser.getLeft()&&insertUser == insertUserHead.getLeft()){//ll
			if(insertUserHead == root){
				insertUser.setHead(null);
				root = insertUser;
				insertUser.setRight(insertUserHead);
				insertUserHead.setLeft(null);
			}else {
				User p = insertUserHead.getHead();
				if(p.getLeft() == insertUserHead)
					p.setLeft(insertUser);
				else
					p.setRight(insertUser);
				insertUser.setRight(insertUserHead);
				insertUserHead.setLeft(null);
			}
		}
		else if(user==insertUser.getLeft()&&insertUser == insertUserHead.getRight()){//lr
			if(insertUserHead == root){
				user.setRight(insertUserHead);
				user.setLeft(insertUser);
				user.setHead(null);
				insertUserHead.setLeft(null);
				insertUser.setRight(null);
				root = user;
			}else {
				User p = insertUserHead.getHead();
				if(p.getLeft() == insertUserHead)
					p.setLeft(user);
				else
					p.setRight(user);
				
				user.setRight(insertUserHead);
				user.setLeft(insertUser);
				insertUserHead.setLeft(null);
				insertUser.setRight(null);
				
			}
		}
		else if(user==insertUser.getRight()&&insertUser == insertUserHead.getLeft()){//rl
			if(insertUserHead == root){
				user.setLeft(insertUserHead);
				user.setRight(insertUser);
				user.setHead(null);
				insertUserHead.setRight(null);
				insertUser.setLeft(null);
				root = user;
			}else {
				User p = insertUserHead.getHead();
				if(p.getLeft() == insertUserHead)
					p.setLeft(user);
				else
					p.setRight(user);
				
				user.setLeft(insertUserHead);
				user.setRight(insertUser);
				insertUserHead.setRight(null);
				insertUser.setLeft(null);
				
			}
		}
	}

其余情况和图二中的1,2情况处理

	public void treeRoateLL(User insertUser,User insertUserHead){
		
		User p = avlUsers.get(avlUsers.size()-1);
		User util;
		
		if(l == 0){//rr
			insertUserHead = p.getRight();
			//insertUser = insertUserHead.getRight();
			
			util = insertUserHead.getLeft();
			if(p == root){
				root = insertUserHead;
				insertUserHead.setLeft(p);
				insertUserHead.setHead(null);
				
				p.setRight(util);
			}else {
				
				User pHead = p.getHead();
				
				insertUserHead.setLeft(p);
				p.setRight(util);
				
				if(pHead.getLeft() == insertUserHead)
					pHead.setLeft(insertUserHead);
				else
					pHead.setRight(insertUserHead);
			}
		}
		else {//ll
			insertUserHead = p.getLeft();
			//insertUser = insertUserHead.getLeft();
			
			util = insertUserHead.getRight();
			if(p == root){
				root = insertUserHead;
				insertUserHead.setRight(p);
				insertUserHead.setHead(null);
				
				p.setLeft(util);
			}else {
				
				User pHead = p.getHead();
				
				insertUserHead.setRight(p);
				p.setLeft(util);
				
				if(pHead.getLeft() == insertUserHead)
					pHead.setLeft(insertUserHead);
				else
					pHead.setRight(insertUserHead);
			}
		}
		
	}

总函数

public boolean addAVL(User friend) throws IllegalArgumentException {
		
		if(friend == null){
			throw new IllegalArgumentException();
		}
		
		else {
			this.beFriend(friend);
			
			//清空list结合
			avlUsers.clear();
			
			/*if(isAvl(root) == false)
				toAVL(friend);*/
			User p = root;
			
			//用while循环遍历,将树中所有不平衡子树的根节点存在list集合中
			while(isAvl(p) == false){
				isAvl(p);
				if(l==1)
					p = avlUsers.get(avlUsers.size()-1).getLeft();
				else {
					p = avlUsers.get(avlUsers.size()-1).getRight();
				}
			}
			//如果list集合中有元素,说明树不平衡
			if(avlUsers.size()>0)
				toAVL(friend);
			return true;
		}
		
		return false;
	}
二叉平衡树（Java）
夏倩倩的博客
08-01 768
在学习了 二叉排序树 的基础上，继续结合TreeMap的源码实现了二叉平衡树。性质平衡二叉搜索树(Balanced Binary Tree)具有以下性质:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。常用算法有红黑树、AVL、Treap、伸展树等。在平衡二叉搜索树中，我们可以看到，其高度一般都良好地维持在O(log2n)，大大降低了操作的时间复杂度。实现
java 实现平衡二叉树
11-23
文档中是我自己实现的用java语言实现(1)判断给定的二叉树是否平衡;（2）二叉树插入新数据后，如果失衡自我旋转调整的方法。
Java数据结构之二叉平衡树
Ascend2015的博客
02-20 770
首先二叉平衡树依然是一课二叉搜索树，关于二叉搜索树以及其平均查找时间的分析，可以见关于二叉查找树的平均查找时间的问题这一篇。我可能写得不太好，所以最好还是参考一些教材，教材的描述通常会更为严谨，博客比较适合临阵磨枪。通常我们认为二叉搜索树的平均查找时间为O(logN)，但不排除极端状况下二叉查找树会成为链表，那么此时，查找时间就会上升到O(N)，这有悖于我们使用二叉查找树的初衷，好在我们遭遇到的问...
平衡二叉树（Java实现）
du_du1的博客
10-15 1428
1、什么是平衡二叉树 平衡因子（Balance Factor） 简称BF：BF(T) = h(l) - h(r），其中 h(l)和 h(r）分别是T的左、右子树的高度。 平衡二叉树（Balance Binary Tree）（AVL树） 空树，或者任一节点左、右子树的高度绝对值不超过1，|BF(T)|<=1。本质是一颗改进后的二叉搜索树。 2、平衡二叉树的调整 RR旋转 RR旋转代码实现 //必须要有一个右节点 //将A和B做右单旋，且更新A和B的树高度 //返回新的根节点B private
平衡二叉树的实现（java）
万嘉龙
04-12 628
node数据结构 package com.assinfo.controller.tree; public class Node { private int data; private int depth; private int balance; private Node parent; private Node lchild; private...
Java实现二叉排序树
09-02
在Java中实现二叉排序树，我们通常会定义一个`Node`类来表示树的节点，它包含键、值以及左右子节点的引用。例如： ```java class Node { int key; Object value; Node left, right; public Node(int item) { ...
Java实现二叉平衡树带注释代码示例
根据提供的文件信息，重点将围绕在Java语言编写的二叉平衡树代码上，该代码具有详细的注释，使得代码可以直接运行。二叉平衡树是一种特殊类型的二叉搜索树（BST），其中任意节点的两个子树的高度差不超过1，从而保证...
Java实现二叉平衡树：数据结构详解
二叉平衡树是Java数据结构中一种重要的数据结构，它在计算机科学与技术领域中扮演着关键角色。本章主要探讨了数据结构的基础概念，特别是针对Java编程环境下的应用。 1.1 数据结构的定义与作用 数据结构是计算机...
掌握JAVA实现二叉平衡树的判断技巧
在探讨如何用Java判断一个二叉树是否是二叉平衡树之前，首先需要理解什么是二叉平衡树。二叉平衡树（也称为AVL树）是一种特殊的二叉搜索树，其中任何节点的两个子树的高度最大差别为1。这意味着，从根到叶子的所有...
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
平衡二叉树的java实现
sdffeng163的博客
07-19 270
平衡二叉树求解步骤： （1）插入节点 （2）找出不平衡因子，在插入过程中找到不平衡因子 （3）旋转，根据不平衡因子判断旋转方式 （4）生成新的平衡二叉树 在求解过程中，最重要步骤详解： 找出不平衡因子（也就是左右子树的高度差值为2或-2的情况） 方法1步骤：a.节点中添加两个属性，左子树高度、右子树高度。b.插入节点c.返回的过程中动态的计算插入节点过程中经过的节点的左子树或右子树的高度。并计算...
平衡二叉树(java)
一起coding，一起嗨。
12-25 1593
平衡二叉树也叫平衡二叉搜索树 (Self-balancingbinarysearch tree) 又被称为AVL树，可以保证查询效率较高。具有以下特点:它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1.并且左右两个子树都是一棵平衡二叉树。
数据结构：二叉平衡树（AVL树）Java实现
biglxl的博客
06-26 567
二叉平衡树（AVL树）Java实现 目录 相关概念 二叉平衡树平衡原理 相关代码 完整代码 （如有任何问题欢迎指出） 相关概念 树的高度： 某结点的高度是指从该结点到叶子结点的最长简单路径边的条数。（从1开始计数，当然你也可以从0开始，咋舒服砸来，这里我从1开始）。 BF因子： 将二叉树上结点的左子树高度减去右子树高度...
平衡二叉树java实现
WukongGo的博客
08-17 224
平衡二叉树 https://leetcode-cn.com/problems/balanced-binary-tree/ 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回 true 。 示例 2: 给定二叉树 [1,2,2,3,3,null...
平衡二叉树详解-java实现
qq_30491663的博客
09-15 604
前置知识： 二叉查找树 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质： 它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1 左右两个子树都是一棵平衡二叉树。 这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡二叉树大部分操作和二叉查找树类似，主要不同在于插入、删
平衡二叉树Java实现
qq_36722687的博客
04-21 273
平衡二叉树Java实现平衡二叉树Java实现 平衡二叉树Java实现 static class TreeNode{ public int val; public TreeNode left; public TreeNode right; public TreeNode(int val){ this.val = val; } } static class BTree{
java实现平衡二叉树
qq_45731129的博客
08-31 1090
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树，可以保证查询效率较高。具有以下特点: 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。举例说明, 看看下面哪些AVL树,为什么?平衡二叉搜索树的左右子树，高度差不能大于1，所以前两个满足。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值