Java实现平衡二叉树

最新推荐文章于 2024-07-05 18:31:01 发布
最新推荐文章于 2024-07-05 18:31:01 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： 算法 文章标签： balanced binary tree java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m1179457922/article/details/81745013
版权

创建平衡二叉树，主要是一旦出现不平衡状态如何更改，这个一直是一个比较晕的，什么左旋右旋很乱。下面跟大家说下如何比较好理解的来进行平衡，阅读本文前需要先明白，不平衡的四种情况即，左左，左右，右左，右右四种情况，如果不懂的，可以自己百度，关于这个很多理解。本文主要是针对对于左旋和右旋理解不了或者想学习用java编写的代码。

其实不管怎么转，其实只是重新改变不平衡节点的左右子树，因此，我们只需要记住不平衡节点的左右子树的左右子树分别该如何得到，就可以。

1、左左情况。

因为左边的过长，所以要吧左边的过长的部分从中间折断，这样就可以把3层节点来弄成两层，这样就可以平衡。

（图片来自网络，侵删）

因此可以看出，新的左子树的左子树为原不平衡节点K2的左子树的左子树的左子树。新的右子树的左子树为不平衡点的左子树的右子树，新右子树的右子树为不平衡点的右子树，右子树的节点为不平衡节点的值，不平衡点值为原不平衡点左子树的值。

代码化为：

BalancedBinaryNode newleftnode=balancedBinaryNode.left.left;
		BalancedBinaryNode newrightnode=new BalancedBinaryNode();
		newrightnode.left=balancedBinaryNode.left.right;
		newrightnode.right=balancedBinaryNode.right;
		newrightnode.data=balancedBinaryNode.data;
		balancedBinaryNode.data=balancedBinaryNode.left.data;
		balancedBinaryNode.left=newleftnode;
		balancedBinaryNode.right=newrightnode;

分析：因为左边过长，所以要折半，即把不平衡点左子树的值作为这部分树的根，那么，根的左子树，也就是新的左子树，所有值都比根要小，而新的右子树要比根大。所以，比根小的 只有根的左子树比他小，所以：新的左子树就是新根原来的左子树：即BalancedBinaryNode newleftnode=balancedBinaryNode.left.left;。剩下的三部分很好理解，新根原来的右子树、原根的右子树、原根的大小关系，很明显：新根原来的右子树<原根<原根的右子树，所以将原根作为新根的右子树，也就是新的右子树，将新根的右子树作为新右子树的左子树，将原根的右子树作为新子树的右子树，

2、右右情况

与左左情况原理相同，只需要左换右即可

3、左右

先附上旋转图（来自网络，侵删）

说实话，这个做法很完美，但是，理解起来有点困难，尤其是没空间想象能力较差。那我们现在来看一看能不能从结果找到什么。

首先，既然是左右了，那么一定是存在 不平衡点、不平衡点左孩子、不平衡点左孩子的有孩子  （原因是左右就是左子树的右子树插入孩子），很显然大小关系：不平衡点左孩子<不平衡点左孩子的右孩子<不平衡点，所以平衡成一颗新树就是  新根节点一定是不平衡节点的左孩子的右孩子，那么新左子树是不平衡点的左孩子，新右子树是不平衡点   ok，来看左右子节点的左右子树分别是啥，先看新左子树的左子树，比新左子树小的 只有原来树中比它小的，那就是原树种不平衡点左子树（新左子树）的左子树，同理，新右子树的右子树就是原不平衡点（新右子树）的右子树。现在还剩下不平衡点的左子树的右子树（新根节点）的左右子树，先看左子树，小于新根节点，所以只能是位于新左子树的一部分，但是，它由于属于新左子树原来右子树的一部分，所以大于新左子树，所以为左子树的右子树，同理，新根节点的原右子树就是右子树的左子树。

所以结论就是：

根节点的值是：不平衡点的左子树的右子树的值

根的左子树节点是：不平衡点的左子树的值

根的右子树节点是：不平衡点的值

新左子树的左子树是：不平衡点的左子树的左子树

新左子树的右子树是：不平衡点左子树的右子树的左子树

新右子树的左子树是：不平衡点左子树的右子树的右子树

新右子树的右子树是：不平衡点的右子树

BalancedBinaryNode newleftnode=new BalancedBinaryNode();
		BalancedBinaryNode newrightnode=new BalancedBinaryNode();
		newleftnode.data=balancedBinaryNode.left.data;
		newleftnode.left=balancedBinaryNode.left.left;
		newleftnode.right=balancedBinaryNode.left.right.left;
		newrightnode.data=balancedBinaryNode.data;
		newrightnode.left=balancedBinaryNode.left.right.right;
		newrightnode.right=balancedBinaryNode.right;
		balancedBinaryNode.data=balancedBinaryNode.left.right.data;
		balancedBinaryNode.left=newleftnode;
		balancedBinaryNode.right=newrightnode;

4、右左理解方式一样

5、下面放入整体代码：

package DataStruct;

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


public class BalancedBinaryTree {
	public static class BalancedBinaryNode{
		public int data;
		public BalancedBinaryNode left;
		public BalancedBinaryNode right;
		public int ceng ;
		public int du;
	}
	public static BalancedBinaryNode init(int data){
		BalancedBinaryNode root=new BalancedBinaryNode();
		root.data=data;
		root.left=null;
		root.right=null;
		root.du=0;
		return root;
	}
	public static void add(BalancedBinaryNode root,int data){
		BalancedBinaryNode temp=root;
		BalancedBinaryNode newNode=new BalancedBinaryNode();
		newNode.left=null;newNode.right=null;newNode.data=data;
		while(true){
			if(data<temp.data){
				if(temp.left!=null){
					temp=temp.left;
				}else{
					temp.left=newNode;
					return ;
				}
			}else if(data>temp.data){
				if(temp.right!=null){
					temp=temp.right;
				}else{
					temp.right=newNode;
					return ;
				}
			}else{
				return;
			}
		}
		
	}
	public static void balance(BalancedBinaryNode root,int data){
		Queue<BalancedBinaryNode> queue=new LinkedList<>();
		if(root==null){
			return ;
		}
		queue.add(root);
		root.ceng=1;
		BalancedBinaryNode balancedBinaryNode;
		while(queue.size()!=0){
			balancedBinaryNode=queue.poll();
			int leftheaght=balancedBinaryNode.left==null?0:getDu(balancedBinaryNode.left);
			int rightheaght=balancedBinaryNode.right==null?0:getDu(balancedBinaryNode.right);
			//该节点平衡
			if(Math.abs(leftheaght-rightheaght)<2){
				if(balancedBinaryNode.left!=null){
					queue.add(balancedBinaryNode.left);
				}
				if(balancedBinaryNode.right!=null){
					queue.add(balancedBinaryNode.right);
				}
			}
			//否则不平衡
			else{
				
				if(leftheaght>rightheaght){
					if(data<balancedBinaryNode.left.data){
						leftAndLeft(balancedBinaryNode);
					}else{
						leftandright(balancedBinaryNode);
					}
				}else{
					if(data<balancedBinaryNode.right.data){
						System.out.println("右左");
						rightandleft(balancedBinaryNode);
					}else{
						rightandright(balancedBinaryNode);
					}
				}
			}
		}
	}
	//左左的平衡
	public static void leftAndLeft(BalancedBinaryNode balancedBinaryNode){
		BalancedBinaryNode newleftnode=balancedBinaryNode.left.left;
		BalancedBinaryNode newrightnode=new BalancedBinaryNode();
		newrightnode.left=balancedBinaryNode.left.right;
		newrightnode.right=balancedBinaryNode.right;
		newrightnode.data=balancedBinaryNode.data;
		balancedBinaryNode.data=balancedBinaryNode.left.data;
		balancedBinaryNode.left=newleftnode;
		balancedBinaryNode.right=newrightnode;
	}
	//右右的平衡
	public static void rightandright(BalancedBinaryNode balancedBinaryNode){
		BalancedBinaryNode newleftnnode=new BalancedBinaryNode();
		BalancedBinaryNode newrightnode=balancedBinaryNode.right.right;
		newleftnnode.left=balancedBinaryNode.left;
		newleftnnode.right=balancedBinaryNode.right.left;
		newleftnnode.data=balancedBinaryNode.data;
		balancedBinaryNode.data=balancedBinaryNode.right.data;
		balancedBinaryNode.left=newleftnnode;
		balancedBinaryNode.right=newrightnode;
	}
	//左右的平衡
	public static void leftandright(BalancedBinaryNode balancedBinaryNode){
		BalancedBinaryNode newleftnode=new BalancedBinaryNode();
		BalancedBinaryNode newrightnode=new BalancedBinaryNode();
		newleftnode.data=balancedBinaryNode.left.data;
		newleftnode.left=balancedBinaryNode.left.left;
		newleftnode.right=balancedBinaryNode.left.right.left;
		newrightnode.data=balancedBinaryNode.data;
		newrightnode.left=balancedBinaryNode.left.right.right;
		newrightnode.right=balancedBinaryNode.right;
		balancedBinaryNode.data=balancedBinaryNode.left.right.data;
		balancedBinaryNode.left=newleftnode;
		balancedBinaryNode.right=newrightnode;
	}
	//右左的旋转
	public static void rightandleft(BalancedBinaryNode balancedBinaryNode){
		BalancedBinaryNode newleftnode=new BalancedBinaryNode();
		BalancedBinaryNode newrightnode=new BalancedBinaryNode();
		newleftnode.data=balancedBinaryNode.data;
		newleftnode.left=balancedBinaryNode.left;
		newleftnode.right=balancedBinaryNode.right.left.left;
		newrightnode.data=balancedBinaryNode.right.data;
		newrightnode.left=balancedBinaryNode.right.left.right;
		newrightnode.right=balancedBinaryNode.right.right;
		balancedBinaryNode.data=balancedBinaryNode.right.left.data;
		balancedBinaryNode.left=newleftnode;
		balancedBinaryNode.right=newrightnode;
		
		
	}
	//获得某个节点的度
	public static int getDu(BalancedBinaryNode binaryNode){
		int result=0;
		if(binaryNode.left==null && binaryNode.right==null){
			result=1;
		}else if(binaryNode.left==null){
			result=1+getDu(binaryNode.right);

		}else if(binaryNode.right==null){
			result=1+getDu(binaryNode.left);
		}else{
			result=1+Math.max(getDu(binaryNode.left),getDu(binaryNode.right));

		}
		return result;
	}
	//
	public static void show(BalancedBinaryNode root){
		Queue<BalancedBinaryNode> queue=new LinkedList<>();
		if(root==null){
			System.out.println("空的");
			return ;
		}
		queue.add(root);
		root.ceng=1;
		BalancedBinaryNode balancedBinaryNode;
		while(queue.size()!=0){
			balancedBinaryNode=queue.poll();
			if(balancedBinaryNode.left!=null){
				balancedBinaryNode.left.ceng=balancedBinaryNode.ceng+1;
				queue.add(balancedBinaryNode.left);
			}
			if(balancedBinaryNode.right!=null){
				balancedBinaryNode.right.ceng=balancedBinaryNode.ceng+1;
				queue.add(balancedBinaryNode.right);
			}
			System.out.println("数据为："+balancedBinaryNode.data+" 所在层数 "+balancedBinaryNode.ceng);
		}
		
	}

}

 

6、测试代码和结果

	package TestMain;

import DataStruct.BalancedBinaryTree;
import DataStruct.BalancedBinaryTree.BalancedBinaryNode;

public class Main {
		public static void main(String args[]) {
//			int data[]={62, 88, 58, 47, 35, 73, 51, 99, 37, 93};
			int data[]={1,2,3,4,5,6,7,8};
			BalancedBinaryNode root=BalancedBinaryTree.init(data[0]);
			for(int i=1;i<data.length;i++){
				BalancedBinaryTree.add(root, data[i]);
				BalancedBinaryTree.balance(root,data[i]);
			}
			BalancedBinaryTree.show(root);
		}
	}

数据为：5 所在层数 1
数据为：3 所在层数 2
数据为：6 所在层数 2
数据为：2 所在层数 3
数据为：4 所在层数 3
数据为：7 所在层数 3
数据为：1 所在层数 4
数据为：8 所在层数 4
 

学点什么吧
关注
专栏目录
java实现平衡二叉树
qq_45731129的博客
08-31 955
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树，可以保证查询效率较高。具有以下特点: 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。举例说明, 看看下面哪些AVL树,为什么?平衡二叉搜索树的左右子树，高度差不能大于1，所以前两个满足。...
平衡二叉树【Java实现】
qq_45702990的博客
08-16 452
平衡二叉树的左旋转、右旋转、双旋转实现
平衡二叉树算法分析
JAVA-Miner
12-11 1835
1、平衡二叉树定义：  平衡二叉树（Balanced Binary Tree或Height-Balanced Tree）又称AVL树。它或者是一颗空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。若将二叉树上结点的平衡因子bf(balance factor)定义为该结点的左子树的深度减去右子树的深度，则平衡二叉树上所有结点的平衡因
Java数据结构——树：二叉树、顺序存储二叉树、线索化二叉树、堆排序、哈夫曼树、二叉排序树、平衡二叉树
2302_77261297的博客
07-05 629
堆排序可能是所有常见的排序中最难的一个，根据尚硅谷-韩顺平老师的讲解，对整套流程一直搞不懂，研究了一个晚上 思路理清了不少。本文按照韩顺平的代码，谈一谈整个堆排序的思路。堆排序是先把一个数组构建成一颗二叉树，这颗二叉树要求所有的非叶子节点都要比他的两个孩子节点大。所以，如果把一个数组构建成大顶堆的二叉树，那么根节点一定是这个数组中最大的值。// 为什么根节点是最大的呢？拿数组 {4,6,8,5,9,13,15,7,3} 举例。这个数组在未经过任何调整的情况下应该是如下图所示：从下到上、从左到右。
平衡二叉树所涉及的一些算法
wangxiaohigh
12-06 274
今晚整那个ubuntu，什么也没弄成，唉，把算法先保留一下吧， 插入函数还没理解透彻呢 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define NULL 0 ...
平衡二叉树
Never_for_Never的专栏
11-14 958
平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉树：它的左子树和右子树的深度之差的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1 很显然，平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降，那么AVL就保持住了(BST)的最好时间复杂度O(logn)，
平衡二叉树（Java）
weixin_48544279的博客
09-07 634
1）平衡二叉树也叫平衡二叉搜索树（Self-balancingBinarySearchTree）又被称为AVL树，可以保证查询效率较高2）具有以下特点：它是一颗空树或它的左右两个子树的高度差绝对值不超过1，并且左右两颗子树都是一颗平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树。
java 实现平衡二叉树
11-23
文档中是我自己实现的用java语言实现(1)判断给定的二叉树是否平衡;（2）二叉树插入新数据后，如果失衡自我旋转调整的方法。
使用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实现
jrymos软件工作室
10-21 339
写完之后，整个人心情都不太好 单元测试 package com.fly.study.structure; import org.junit.Before; import org.junit.Test; import org.omg.PortableInterceptor.INACTIVE; import java.util.Arrays; import java.util.Collection...
平衡二叉树（Java实现）
du_du1的博客
10-15 1375
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_Java 实现平衡二叉树
weixin_29058331的博客
02-13 155
输入一棵二叉树，判断该二叉树是否是平衡二叉树。平衡二叉树平衡二叉树(Balanced BinaryTree)又被称为AVL树。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树一般是一个有序树，它具有二叉树的所有性质，其遍历操作和二叉树的遍历操作相同。但是由于其对二叉树施加了额外限制，因而其添加、删除操作都必须保证平衡二叉树的性子...
平衡二叉树的实现原理（代码实现）- 数据结构和算法78
weixin_33725270的博客
12-29 93
平衡二叉树的实现原理 让编程改变世界 Change the world by program 上节课我们花了不少的时间和精力从意识形态上进一步的了解了AVL树（也就是平衡二叉树）的实现原理，但是小甲鱼知道，很多鱼油在想的方面基本是无敌了，但是到了要你用代码来实现的时候，脑袋里就只能蹦出两字：抽象！ 这节课小甲鱼就带大家一起来化腐朽为神奇,化干戈为玉帛,化不可能为可能,谈笑...
使用Java实现平衡二叉树
qq_56323695的博客
05-28 1248
使用Java实现平衡二叉树 二叉树是一种较为复杂的数据结构,二叉树算法在数据查询时的时间复杂度为 O(log n)(n为保存元素个数). 但是普通的二叉树在数据添加和删除时很容易出现树结构不平衡问题 ,而使用平衡二叉树则不会出现这样的问题. 如何实现? 我们通过旋转完成 如:左旋转 怎么处理-进行左旋转 1.创建一个新的节点newnode(以4这个值创建)，创建一个新的节点，值等于当前根节点的值 //把新节点的左子树设置了当前节点的左子树 2.newnode.left=left //把新节点的右子树设置为当
JAVA代码实现平衡二叉树
qq_41665523的博客
03-22 1222
平衡二叉树 平衡二叉树又叫AVL树，它是在二叉排序树的基础上进行了树结构的调整，使其根节点的左右子树的高度差一致。可以保证查询效率更加高效。 平衡二叉树涉及到左旋转、右旋转和双旋转，接下来分别用图解分析一下： 左旋转 右旋转 双旋转 代码如下： package com.avl; /* * 平衡二叉树： * 1.左旋转 * 2.右旋转 * 3.双旋转 */ public class...
平衡二叉树（java代码实现）
m0_46400910的博客
01-07 903
平衡二叉树特点 平衡二叉树就是在二叉排序树的基础上保持`平衡`:**一颗空树**或**它的左右两个子树的高度差的绝对值不超过1**，并且**左右两子树都是一颗平衡二叉树** 平衡方法 在添加完成一个树节点后，则做判断进行调整，若不平衡，则做出以下处理 1. (右子树的高度-左子树的高度) > 1 再进行判断 ①如果**它的右子树的左子树的高度大于它的右子树的右子树的高度**，则**先对右子结点进行右旋转**，**然后再对当前结点进行左旋转** 左旋转右旋转
平衡二叉树详解-java实现
qq_30491663的博客
09-15 532
前置知识： 二叉查找树 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质： 它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1 左右两个子树都是一棵平衡二叉树。 这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡二叉树大部分操作和二叉查找树类似，主要不同在于插入、删
Java平衡二叉树实现
05-19
Java平衡二叉树的实现可以使用Java集合框架提供的TreeSet或TreeMap，它们内部都使用红黑树实现平衡二叉树。 红黑树是一种自平衡的二叉查找树，它保证任何一个节点的左右子树的高度差小于两倍。红黑树通过节点的颜色...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值