【面试】【二叉树】java 实现二叉树插入、旋转调整维护自平衡

最新推荐文章于 2024-08-16 09:16:07 发布
置顶 最新推荐文章于 2024-08-16 09:16:07 发布
阅读量518 收藏
点赞数
分类专栏： 面试 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011059021/article/details/84371302
版权

1.定义节点对象

package com.wang.tree;
/**
 * 二叉树节点类
 * @description
 * @author wang
 * @date 2018年11月20日
 */
public class TreeNode {
	private int data;
	private TreeNode leftNode;
	private TreeNode rightNode;
	private TreeNode parentNode;
	
	public TreeNode() {
		super();
		// TODO 自动生成的构造函数存根
	}
	
	public TreeNode(int data) {
		super();
		this.data = data;
	}

	public int getData() {
		return data;
	}

	public void setData(int data) {
		this.data = data;
	}

	public TreeNode getLeftNode() {
		return leftNode;
	}
	public void setLeftNode(TreeNode leftNode) {
		this.leftNode = leftNode;
	}
	public TreeNode getRightNode() {
		return rightNode;
	}
	public void setRightNode(TreeNode rightNode) {
		this.rightNode = rightNode;
	}
	public TreeNode getParentNode() {
		return parentNode;
	}
	public void setParentNode(TreeNode parentNode) {
		this.parentNode = parentNode;
	}
	
	
	

}

2.工具类加入 插入、左旋、右旋等方法

package com.wang.tree;
/**
 * 二叉平衡树(AVL树)
 * @description
 * @author wang
 * @date 2018年11月20日
 */
public class AVLTreeUtil {
	/**
	 * 判断二叉树是否是平衡二叉树
	 * 缺点:重复的计算子树的高度
	 * @param node (root根节点，迭代遍历)
	 * @return
	 */
	public static boolean isBalance=true;
	public static boolean isBalanced(TreeNode node){
		//如果是空树,则是平衡二叉树
		if(null == node){
			return true;
		}
		//如果不为空
		//左子树或者右子树为空,则高度差肯定小于2则为平衡二叉树
		if(null == node.getLeftNode() || null == node.getRightNode()){
			return true;
		}
		//如果左子树或者右子树都不为空,则比较高度差
		// 计算得到左子树的深度
        int leftDepth = treeDepth(node.getLeftNode());
        // 计算得到右子树的深度
        int rightDepth = treeDepth(node.getRightNode());
        // 如果高度差大于1，不满足平衡二叉的条件
        if (Math.abs(leftDepth - rightDepth) > 1) {
            return false;
        }
        // 判断左子树和右子树是否满足平衡二叉树的条件
        return isBalanced(node.getLeftNode()) && isBalanced(node.getRightNode());
	}
	
	public static int treeDepth(TreeNode node){
		if(null == node){
			return 0;
		}
		//计算左子树的深度
		int left = treeDepth(node.getLeftNode());
		//计算右子树的深度
		int right = treeDepth(node.getRightNode());
		// 树root的深度=路径最长的子树深度 + 1
		return left >= right ? (left + 1) : (right + 1);
	}
	/**
	 * 可以用后序遍历，从下到上遍历如果子树中任一不满足条件返回 false<p>
     * 否则返回 true 这样每个节点的高度只会算一次
	 * @param node
	 * @return
	 */
	public static boolean isBalanced1(TreeNode node){
		treeDepth1(node);
		return isBalance;
	}
	public static int treeDepth1(TreeNode root){
		if(root==null)
            return 0;
        int left=treeDepth1(root.getLeftNode());
        //左子树高度
        int right=treeDepth1(root.getRightNode());
        //右子树高度
        if(Math.abs(left-right)>1)
        {
            isBalance=false;
            //只要有一个子树的左右子树的高度绝对值大于 1 isBalance=false
        }
        return Math.max(left, right)+1;
	}
	
	/**
	 * 向AVL树中插入数据
	 * @param root
	 * @param Data
	 */
	public static void add(TreeNode root, int data){
		if(data < root.getData()){
			if(root.getLeftNode() != null){
				add(root.getLeftNode(),data);
			}else{
				TreeNode newLeftNode = new TreeNode(data);
				root.setLeftNode(newLeftNode);
				newLeftNode.setParentNode(root);
			}
		}else{
			if(root.getRightNode() != null){
				add(root.getRightNode(),data);
			}else{
				TreeNode newRightNode = new TreeNode(data);
				root.setRightNode(newRightNode);
				newRightNode.setParentNode(root);
			}
		}
		//插入完成
		//如果不再平衡,需要旋转
		int balance = calculateBalance(root);
		//左子树高，应该右旋(包括左左,左右)
		if(balance >= 2){
			//右孙高，先左旋(左右,旋转两次,先左旋再右旋)
			if(calculateBalance(root.getLeftNode()) == -1){
				left_rotate(root.getLeftNode());
			}
			//(左左,旋转一次,直接右旋)
			right_rotate(root);
		}
		
		//右子树高,应该左旋(包括右右,右左)
		if(balance <= -2){
			//左孙高，先右旋(右左,旋转两次,先右旋再左旋)
			if(calculateBalance(root.getRightNode()) == 1){
				right_rotate(root.getRightNode());
			}
			//(右右,旋转一次,直接左旋)
			left_rotate(root);
		}
		
	}
	
	/**
	 * 插入新节点
	 * @param root
	 * @param data
	 */
	public static void insert(TreeNode root, int data){
		if(data < root.getData()){
			if(root.getLeftNode() != null){
				insert(root.getLeftNode(),data);
			}else{
				TreeNode newLeftNode = new TreeNode(data);
				root.setLeftNode(newLeftNode);
				newLeftNode.setParentNode(root);
			}
		}else{
			if(root.getRightNode() != null){
				insert(root.getRightNode(),data);
			}else{
				TreeNode newRightNode = new TreeNode(data);
				root.setRightNode(newRightNode);
				newRightNode.setParentNode(root);
			}
		}
	}
	
	/**
	 * 计算平衡因子(左右子树高度(深度)之差)
	 * @param root
	 * @return
	 */
	public static int calculateBalance(TreeNode root){
		if(root == null){
			return 0;
		}
		//计算左子树的深度
		int left = treeDepth(root.getLeftNode());
		//计算右子树的深度
		int right = treeDepth(root.getRightNode());
		return (left-right);
		
	}
	
	/**
	 * 左旋
	 * @param root
	 */
	public static void left_rotate(TreeNode p){
		//父节点
		TreeNode pParent = p.getParentNode();
		//右子节点
		TreeNode pRight = p.getRightNode();
		//右子节点的左节点(孙节点)
		TreeNode pRightLeft = pRight.getLeftNode();
		//右子节点变父
		pRight.setParentNode(pParent);
		if(pParent != null){
			if(p == pParent.getLeftNode()){
				pParent.setLeftNode(pRight);
			}else if(p == pParent.getRightNode()){
				pParent.setRightNode(pRight);
			}
		}
		pRight.setLeftNode(p);
		p.setParentNode(pRight);
		//右左孙变右子
		p.setRightNode(pRightLeft);
		if(pRightLeft != null){
			pRightLeft.setParentNode(p);
		}
	}
	
	
	/**
	 * 右旋
	 * @param root
	 */
    public static void right_rotate(TreeNode p){
    	//父节点
    	TreeNode pParent = p.getParentNode();
    	//左子节点
    	TreeNode pLeft = p.getLeftNode();
    	//左子节点的右节点(孙节点)
    	TreeNode pLeftRight = pLeft.getRightNode();
    	//左子变父
    	pLeft.setParentNode(pParent);
    	//判断p原来是pParent的左子还是右子,并改为赋予pLeft
    	if(pParent != null){
    		if(p == pParent.getLeftNode()){
    			pParent.setLeftNode(pLeft);
    		}else if(p == pParent.getRightNode()){
    			pParent.setRightNode(pLeft);
    		}
    	}
    	pLeft.setRightNode(p);
    	p.setParentNode(pLeft);
    	//左右孙变左子
    	p.setLeftNode(pLeftRight);
    	if(pLeftRight != null){
    		pLeftRight.setParentNode(p);
    	}
		
	}
    
    /**
     * 前序遍历 中--左--右(DLR)
     * @param root
     */
    public static void preorderTraversal(TreeNode root){
    	if(root != null){
    		System.out.println(root.getData() +"->");
    		preorderTraversal(root.getLeftNode());
    		preorderTraversal(root.getRightNode());
    		
    	}
    }
    
    /**
     * 中序遍历 左--中--右(LDR)
     * @param root
     */
    public static void inorderTraversal(TreeNode root){
    	if(root != null){
    		inorderTraversal(root.getLeftNode());
    		System.out.println(root.getData() +"->");
    		inorderTraversal(root.getRightNode());
    		
    	}
    }
    
    /**
     * 后序遍历 左--右--中(LRD)
     * @param root
     */
    public static void postorderTraversal(TreeNode root){
    	if(root != null){
    		postorderTraversal(root.getLeftNode());
    		postorderTraversal(root.getRightNode());
    		System.out.println(root.getData() +"->");
    	}
    }
    
	
	

}

3.测试代码

package com.wang.tree;
/**
 * 测试二叉平衡树插入
 * @description
 * @author wang
 * @date 2018年11月22日
 */
public class AVLTreeTest2 {
	public static void main(String[] args) {
		TreeNode root = new TreeNode(5);
		TreeNode node2 = new TreeNode(3);
		TreeNode node3 = new TreeNode(6);
		TreeNode node4 = new TreeNode(1);
		TreeNode node5 = new TreeNode(4);
		root.setLeftNode(node2);
		root.setRightNode(node3);
		node2.setParentNode(root);
		node2.setLeftNode(node4);
		node2.setRightNode(node5);
		node4.setParentNode(node2);
		node5.setParentNode(node2);
		System.out.println("=====开始中序遍历=====");
		AVLTreeUtil.inorderTraversal(root);
		AVLTreeUtil.add(root, 2);
		System.out.println("=====开始中序遍历=====");
		AVLTreeUtil.inorderTraversal(node2);
	}
	

}

输出结果：

=====开始中序遍历=====
1->
3->
4->
5->
6->
=====开始中序遍历=====
1->
2->
3->
4->
5->
6->

 

KK_在努力
关注
专栏目录
java进阶篇--红黑树和平衡二叉树有什么区别？
爱分享的淘金达人
06-22 3633
数据结构属于理解一些源码和技术所必备的知识，比如要读懂 Java 语言中 TreeMap 和 TreeSet 的源码就要懂红黑树的数据结构，不然是无法理解源码中关于红黑树数据的操作代码的，比如左旋、右旋、添加和删除操作等。因此本课时我们就来学习一下数据结构的基础知识，方便看懂源码或者是防止面试中被问到。 我们本课时的面试题是，红黑树和二叉树有什么区别？ 回答： 要回答这个问题之前，我们先要弄清什么是二叉树？什么是红黑树？ 二叉树（Binary Tree）是指每个节点最多只有两个分支的树结构，即不存在
基础算法平衡二叉树（AVL）树实现
2401_83915900的博客
04-20 251
定义AVL树结点：// TreeNode AVL结点定义data int // 结点数据height int // 结点高度left *TreeNode // 左孩子right *TreeNode // 右孩子// NewTreeNode 构建一个新结点height: 0,left: nil,复制代码可以在二叉查找树的基础上进行修改，这里重点实现插入和删除的操作，其他一些基本上都和二叉树操作一样。// Insert 插入// TODO。
二叉树旋转--左旋|右旋
weixin_43855206的博客
03-16 2224
二叉树旋转 二叉树的旋转主要是应用在AVL树中，当添加一个节点时候导致左右两个子树的高度差不在是-1 ， 1 ， 0而变成了2 或者-2。此时就需要用到左旋/右旋了。当然左右旋或者有左旋也是基于左旋和右旋的就是顺序不同，理清旋转的顺序就可以直接调用 ...
java语言实现平衡二叉树的左旋转、右旋转和双旋转
Willow_zhu的博客
03-25 615
平衡二叉树又叫平衡二叉搜索树，或者AVL树，有如下特点： 可以是一棵空树 或者它的左右子树的高度差的绝对值不大于1，并且左右子树也是平衡二叉树 当二叉树不平衡的时候，可以通过“旋转”来使它平衡 左旋转（适用于右子树高度 - 左子树高度 > 1） 右旋转（适用于左子树高度 - 右子树高度 > 1） 双旋转 左旋转 思路分析 创建一个新的节点，且其值等于二叉树根节点的...
数据结构——二叉树
最新发布
2301_80373479的博客
08-16 1837
轻松学会二叉树
Java-----树（平衡二叉树的旋转）
m0_64591071的博客
02-11 181
平衡二叉树 旋转的时机 怎么样旋转成为平衡二叉树
《LeetCode力扣练习》第226题 翻转二叉树 Java
XRT_knives的博客
03-14 1437
《LeetCode力扣练习》第226题 翻转二叉树 Java 一、资源 题目： 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 示例 1： 输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1] 示例 2： 输入：root = [2,1,3] 输出：[2,3,1] 示例 3： 输入：root = [] 输出：[] 提示： 树中节点数目范围在 [0, 100] 内 -100 <= Node.val <= 100 来源：力扣（Le
平衡二叉树旋转
weixin_34146410的博客
08-18 150
　　首先附上本文节选地址：http://www.cnblogs.com/huangxincheng/archive/2012/07/22/2603956.html   　　二叉查找树不是严格的O(logN)，导致了在真实场景中没有用武之地，谁也不愿意有O(N)的情况发生，作为一名码农，肯定会希望能把“范围查找”做到地球人都不能优化的地步。 当有很多数据灌到我的树中时，我肯定会希望最好是以“完全...
java 实现平衡二叉树
11-23
文档中是我自己实现的用java语言实现(1)判断给定的二叉树是否平衡;（2）二叉树插入新数据后，如果失衡自我旋转调整的方法。
Java树形结构面试题深入探讨：平衡树与二叉树的5大应用技巧
[Java树形结构面试题深入探讨：平衡树与二叉树的5大应用技巧](https://blog.skillfactory.ru/wp-content/uploads/2023/02/avl-4-1697922.png) # 1. 树形结构的基础与概念解析 在计算机科学与信息技术领域，树形结构...
平衡二叉树及其旋转实现原理（Java实现）
F_chords的博客
11-13 744
今天我们来聊一聊 平衡二叉树 的基本实现原理。 我们都知道，平衡二叉树是二叉搜索树的优化版本，进一步提高了二叉搜索树的查找效率。 如：当我们用{1，2，3，4，5，6，7}这样的顺序来创建一棵二叉搜索树并添加相应的节点时，根据二叉搜索树的对应添加方式，最终就会出现这样的情况： 当我们用这样的二叉搜索树查找时，单论时间复杂度，与普通的链表是一样的。（比如我们需要查找“7”这个节点，就需要从头开始比...
Java-平衡二叉树旋转
weixin_41227335的博客
03-11 450
转载自：https://blog.csdn.net/qq_24336773/article/details/81712866
二叉树旋转
热门推荐
进击的小学生
03-03 1万+
本文我们来学习二叉树的另一种操作——旋转。掌握了这个神技，你将会在平衡树的道路上所向披靡。 1. 什么是旋转 二叉树节点旋转一共有两种操作：左旋和右旋。 如图 1 所示，左边的二叉树通过左旋得到右边的二叉树；反之右旋同理。（a, b, c 表示子树，而不是单独表示一个节点） 图1 左旋和右旋 左旋：是以节点的"右分支"为轴，进行逆时针旋转。我们将左旋操作定义为 left_rotate. 右...
Java 平衡二叉树的旋转
Regino的博客
03-03 518
本文介绍了 Java 中平衡二叉树的旋转的相关内容。。。
java -平衡二叉树（左旋转、右旋转、双旋转）
Oldsong的博客
08-26 866
平衡二叉树 平衡二叉树又叫平衡二叉搜索树，可以保证查询效率较高。 特点一棵树它左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 右旋转 构建二叉查找树： 构成的二叉树的形状： 此时，左右子树高度差为为2，根节点值为10 这时二叉树：左子树高度-右子树的高度=2 不满足平衡二叉树，为了让二叉树成为平衡二叉树就需要进行右旋转降低左子树的高度，增加右子树的深度。 右旋转的步骤：（紫色为当前结点，红色为新结点） //右旋转方法 private void rightRotat
二叉树反转（java版）
kecongxiao的博客
12-13 3913
leetcode oj第226题，难度级别为easy，巩固一下二叉树的相关知识。 二叉树的类型定义： // Definition for a binary tree node. class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) {
平衡二叉树——旋转与插入（Java 语言描述）
ypy9323的博客
06-09 308
对平衡二叉树的研究，大概已有半年之久。最近才算是对它有所领悟。因为网上好多博文对其讲解的都很好，在此就不再详述，只对其进行分篇章总结。 一、左旋转 在网上找到一左转GIF示意图。我借用一下： 在不平衡子树的右子树的右孩子插入结点导致的不平衡应该进行左旋转。 /** * 约定null节点的高度为-1， 叶子结点高度为0。到根结点变大; * @param node 某一节...
平衡二叉树的旋转_平衡二叉树的旋转
weixin_39614228的博客
12-06 245
一、平衡二叉树的定义为避免树的高度增长过快，降低二叉树的排序性能，规定在插入和删除二叉树结点时，保证任意结点的左右子树高度差的绝对值不大于1。这样的二叉树被称为平衡二叉树(Balanced Binary Tree)。二、平衡因子平衡因子：结点的平衡因子 = 结点的左子树深度 —结点的右子树深度。若平衡因子的取值为-1、0或1时，该节点是平衡的，否则是不平衡的。最低不平衡...
平衡二叉树的插入与旋转实现
总结来说，平衡二叉树的核心在于保持树的平衡，通过插入节点后的旋转操作和平衡调整，维持树的高度对称，从而优化搜索性能。在给定的代码示例中，展示了如何通过旋转和平衡调整函数实现这一目标。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值