平衡二叉树-java代码实现

最新推荐文章于 2022-11-28 20:56:25 发布
最新推荐文章于 2022-11-28 20:56:25 发布
阅读量442 收藏 1
点赞数 1
分类专栏： 算法
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/112851332
版权

资料引入说明

  • 平衡二叉树理论知识参考：https://blog.csdn.net/dengjili/article/details/111463328

  • 二叉排序树理论知识参考：https://blog.csdn.net/dengjili/article/details/111503799

  • 二叉排序树-java代码实现:https://blog.csdn.net/dengjili/article/details/111992147

平衡二叉树是在二叉排序树代码基础上进行平衡的，这里直接使用了二叉排序树代码，本章节重点在于讲解平衡的过程

代码说明

定义节点如下，增加平衡因子，结点高度，指向父结点的引用三个属性

public class AVLNode {
	private int value;
	private AVLNode leftNode;
	private AVLNode rightNode;
	private int balanceFactor;
	private int length;
	private AVLNode parentNode;
	// setter getter

采用层次遍历输出，便于观察使用，输出结点信息

public class AVLLevelTraversal {
	public static void traversal(AVLNode AVLNode) {
		System.out.println("----------------------");
		Queue<AVLNode> queue = new LinkedBlockingDeque<>();
		queue.add(AVLNode);
		
		while (!queue.isEmpty()) {
			AVLNode pollNode = queue.poll();
			System.out.println(String.format("value=%s, length=%s, balanceFactor=%s", pollNode.getValue(), pollNode.getLength(), pollNode.getBalanceFactor()));
			AVLNode leftNode = pollNode.getLeftNode();
			if (leftNode != null) {
				queue.add(leftNode);
			}
			AVLNode rightNode = pollNode.getRightNode();
			if (rightNode != null) {
				queue.add(rightNode);
			}
		}
	}
}

平衡二叉树增加实现，其中复用了二叉排序树功能，新增的单独标注

public class AVLTree {

	/**  ================================================*/
	/**  二叉树排序功能                                                    开始               */
	/**  ================================================*/
	public static AVLNode insert(AVLNode AVLNode, int value) {
		if (AVLNode == null) {
			AVLNode = new AVLNode(value);
		} else {
			int currentValue = AVLNode.getValue();
			if (currentValue > value) {
				AVLNode leftAVLNode = AVLNode.getLeftNode();
				leftAVLNode = insert(leftAVLNode, value);
				AVLNode.setLeftNode(leftAVLNode);
				leftAVLNode.setParentNode(AVLNode);
			} else if (currentValue < value) {
				AVLNode rightAVLNode = AVLNode.getRightNode();
				rightAVLNode = insert(rightAVLNode, value);
				AVLNode.setRightNode(rightAVLNode);
				rightAVLNode.setParentNode(AVLNode);
			} 
			// don't deal with currentValue equals with value
		}
		return AVLNode;
	}
	
	public static AVLNode delete(AVLNode root, int value) {
		AVLNode isExistAVLNode = search(root, value);
		if (isExistAVLNode == null) {
			return root;
		}
		
		// 标记待删除节点的父结点，其中若删除的是根节点，则parentAVLNode为空
		AVLNode parentAVLNode = null;
		AVLNode currentAVLNode = root;
		while (currentAVLNode != null && currentAVLNode.getValue() != value) {
			parentAVLNode = currentAVLNode;
			if (currentAVLNode.getValue() > value) {
				currentAVLNode = currentAVLNode.getLeftNode();
			} else {
				currentAVLNode = currentAVLNode.getRightNode();
			}
		}
		
		// 删除，分三种情况处理
		// 1. 叶子节点
		if (currentAVLNode.getLeftNode() == null && currentAVLNode.getRightNode() == null) {
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(null);
				} else {
					parentAVLNode.setRightNode(null);
				}
			} else {
				root = null;
			}
		}
		
		// 2. 只存在一个子节点
		else if (currentAVLNode.getLeftNode() == null && currentAVLNode.getRightNode() != null) {
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(currentAVLNode.getRightNode());
				} else {
					parentAVLNode.setRightNode(currentAVLNode.getRightNode());
				}
			} else {
				root = currentAVLNode.getRightNode();
			}
		} 
		else if (currentAVLNode.getLeftNode() != null && currentAVLNode.getRightNode() == null) {
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(currentAVLNode.getLeftNode());
				} else {
					parentAVLNode.setRightNode(currentAVLNode.getLeftNode());
				}
			} else {
				root = currentAVLNode.getLeftNode();
			}
		}
		// 3. 存在两个子节点（采用替代法-可重用代码：找出被删除节点的右子树，找出最大的结点，替换被删除的结点）
		else if (currentAVLNode.getLeftNode() != null && currentAVLNode.getRightNode() != null) {
			// 3.1  找出右子树最大节点
			AVLNode currentMinAVLNode = currentAVLNode;
			while (currentMinAVLNode.getLeftNode() != null) {
				currentMinAVLNode = currentMinAVLNode.getLeftNode();
			}
			// 3.2 删除右子树最大节点
			root = delete(root, currentMinAVLNode.getValue());
			// 3.3 替换待删除节点
			currentMinAVLNode.setLeftNode(currentAVLNode.getLeftNode());
			currentMinAVLNode.setRightNode(currentAVLNode.getRightNode());
			// 3.4 设置父结点子引用
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(currentMinAVLNode);
				} else {
					parentAVLNode.setRightNode(currentMinAVLNode);
				}
			} else {
				root = currentMinAVLNode;
			}
		}
		
		return root;
	}
	
	public static AVLNode search(AVLNode AVLNode, int value) {
		if (AVLNode == null) {
			return null;
		}
		int currentValue = AVLNode.getValue();
		if (value == currentValue) {
			return AVLNode;
		} else if (currentValue > value) {
			AVLNode leftAVLNode = AVLNode.getLeftNode();
			return search(leftAVLNode, value);
		} else {
			AVLNode rightAVLNode = AVLNode.getRightNode();
			return search(rightAVLNode, value);
		}
	}
	
	public static AVLNode search2(AVLNode AVLNode, int value) {
		AVLNode currentAVLNode = AVLNode;
		while (currentAVLNode != null) {
			int currentValue = currentAVLNode.getValue();
			if (value == currentValue) {
				return currentAVLNode;
			} else if (currentValue > value) {
				currentAVLNode = currentAVLNode.getLeftNode();
			} else {
				currentAVLNode = currentAVLNode.getRightNode();
			}
		}
		return null;
	}
	
	
	public static AVLNode createBST(int[] nums) {
		AVLNode root = null;
		for (int value : nums) {
			root = insert(root, value);
		}
		return root;
	}
	
	/**  ================================================*/
	/**  二叉树排序功能                                                    结束               */
	/**  ================================================*/
	
	// ==================================================//
	
	/**  ================================================*/
	/**  平衡二叉树功能                                                    开始               */
	/**  ================================================*/
	
	public static AVLNode createAVL(int[] nums) {
		AVLNode root = null;
		for (int value : nums) {
			root = insertAVL(root, value);
		}
		return root;
	}
	
	public static AVLNode insertAVL(AVLNode AVLNode, int value) {
		// 复用原二叉排序树功能
		AVLNode root = insert(AVLNode, value);
		// 计算平衡影子
		resetBalanceFactor(root);
		// 平衡
		root = rebalance(root);

		return root;
	}

	/**
	 * <p>Description: 核心平衡方法</p>
	 */
	private static AVLNode rebalance(AVLNode root) {
		// 判断树是否满足平衡二叉树，不是平衡二叉树返回非平衡结点
		AVLNode nonAVLNode = getNonAVLNode(root);

		while (nonAVLNode != null) {
			// 找出调整结点
			AVLRotate aVLRotate = new RoutingAVLRotate();
			AVLNode rootAVLSubTree = aVLRotate.rotate(nonAVLNode);
			// 判断旋转结点是否为原根节点
			if (rootAVLSubTree.getParentNode() == null) {
				root = rootAVLSubTree;
			}
			resetBalanceFactor(root);
			// redo
			nonAVLNode = getNonAVLNode(root);
		}
		return root;
	}
	
	private static void resetBalanceFactor(AVLNode AVLNode) {
		AVLNode leftNode = AVLNode.getLeftNode();
		AVLNode rightNode = AVLNode.getRightNode();
		
		int leftAVLNodeLength = 0;
		if (leftNode != null) {
			resetBalanceFactor(leftNode);
			leftAVLNodeLength = leftNode.getLength();
		}
		int rightAVLNodeLength = 0;
		if (rightNode != null) {
			resetBalanceFactor(rightNode);
			rightAVLNodeLength = rightNode.getLength();
		}
		
		// 根据左右子树的的高度计算节点的高度、平衡因子
		int AVLNodeLength = Math.max(leftAVLNodeLength, rightAVLNodeLength) + 1;
		int AVLNodeBalanceFactor = leftAVLNodeLength - rightAVLNodeLength;
		AVLNode.setLength(AVLNodeLength);
		AVLNode.setBalanceFactor(AVLNodeBalanceFactor);
	}
	
	/**  
	 * <p>Description: 遍历搜索所有结点是否满足平衡二叉树-[通用]</p>  
	 */
	private static AVLNode getNonAVLNode(AVLNode node) {
		AVLNode nonAVLNode = null;
		
		// 使用层次遍历，找出平衡因子为+-2的结点
		Queue<AVLNode> queue = new LinkedBlockingDeque<>();
		queue.add(node);
		
		while (!queue.isEmpty()) {
			AVLNode pollNode = queue.poll();
			int balanceFactor = pollNode.getBalanceFactor();
			if (balanceFactor > 1 || balanceFactor < -1) {
				nonAVLNode = pollNode;
				break;
			}
			AVLNode leftNode = pollNode.getLeftNode();
			if (leftNode != null) {
				queue.add(leftNode);
			}
			AVLNode rightNode = pollNode.getRightNode();
			if (rightNode != null) {
				queue.add(rightNode);
			}
		}
		
		return nonAVLNode;
	}
	
	/**  ================================================*/
	/**  平衡二叉树功能                                                    结束               */
	/**  ================================================*/
	
}

核心平衡代码，这里抽象为单独的几个类实现

AVLRotate aVLRotate = new RoutingAVLRotate();
AVLNode rootAVLSubTree = aVLRotate.rotate(nonAVLNode);

平衡接口定义

public interface AVLRotate {
	AVLNode rotate(AVLNode rotateNode);
}

平衡路由选择

public class RoutingAVLRotate implements AVLRotate {
	@Override
	public AVLNode rotate(AVLNode rotateNode) {
		AVLRotate aVLRotate = null;
		if (rotateNode.getBalanceFactor() > 0) {
			AVLNode leftNode = rotateNode.getLeftNode();
			if (leftNode.getBalanceFactor() > 0) {
				// LL
				aVLRotate = new LLAVLRotate();
			} else {
				// LR
				aVLRotate = new LRAVLRotate();
			}
		} else {
			AVLNode rightNode = rotateNode.getRightNode();
			if (rightNode.getBalanceFactor() > 0) {
				// RL
				aVLRotate = new RLAVLRotate();
			} else {
				// RR
				aVLRotate = new RRAVLRotate();
			}
		}
		
		AVLNode rootAVLSubTree = aVLRotate.rotate(rotateNode);
		return rootAVLSubTree;
	}
}

LL实现

public class LLAVLRotate implements AVLRotate {
	@Override
	public AVLNode rotate(AVLNode rotateNode) {
		AVLNode rootAVLSubTree = rotateNode.getLeftNode(); 
		int value = rotateNode.getValue();
		AVLNode parentNode = rotateNode.getParentNode();
		rootAVLSubTree.setParentNode(parentNode);
		if (parentNode != null) {
			if (parentNode.getValue() > value) {
				parentNode.setLeftNode(rootAVLSubTree);
			} else {
				parentNode.setRightNode(rootAVLSubTree);
			}
		}
		
		// 调整
		rotateNode.setLeftNode(rootAVLSubTree.getRightNode());
		rootAVLSubTree.setRightNode(rotateNode);
		
		rotateNode.setParentNode(rootAVLSubTree);
		
		return rootAVLSubTree;
	}
}

LR实现

public class LRAVLRotate implements AVLRotate {
	@Override
	public AVLNode rotate(AVLNode rotateNode) {
		AVLNode leftNode = rotateNode.getLeftNode();
		AVLNode rootAVLSubTree = leftNode.getRightNode(); 
		int value = rotateNode.getValue();
		AVLNode parentNode = rotateNode.getParentNode();
		rootAVLSubTree.setParentNode(parentNode);
		if (parentNode != null) {
			if (parentNode.getValue() > value) {
				parentNode.setLeftNode(rootAVLSubTree);
			} else {
				parentNode.setRightNode(rootAVLSubTree);
			}
		}
		
		// 调整
		leftNode.setRightNode(rootAVLSubTree.getLeftNode());
		rotateNode.setLeftNode(rootAVLSubTree.getRightNode());
		rootAVLSubTree.setLeftNode(leftNode);
		rootAVLSubTree.setRightNode(rotateNode);
		
		rotateNode.setParentNode(rootAVLSubTree);
		leftNode.setParentNode(rootAVLSubTree);
		
		return rootAVLSubTree;
	}
}

RL实现

public class RLAVLRotate implements AVLRotate {
	@Override
	public AVLNode rotate(AVLNode rotateNode) {
		AVLNode rightNode = rotateNode.getRightNode();
		AVLNode rootAVLSubTree = rightNode.getLeftNode(); 
		int value = rotateNode.getValue();
		AVLNode parentNode = rotateNode.getParentNode();
		rootAVLSubTree.setParentNode(parentNode);
		if (parentNode != null) {
			if (parentNode.getValue() > value) {
				parentNode.setLeftNode(rootAVLSubTree);
			} else {
				parentNode.setRightNode(rootAVLSubTree);
			}
		}
		
		// 调整
		rightNode.setLeftNode(rootAVLSubTree.getRightNode());
		rotateNode.setRightNode(rootAVLSubTree.getLeftNode());
		rootAVLSubTree.setLeftNode(rotateNode);
		rootAVLSubTree.setRightNode(rightNode);
		
		rotateNode.setParentNode(rootAVLSubTree);
		rightNode.setParentNode(rootAVLSubTree);
		
		return rootAVLSubTree;
	}
}

RR实现

public class RRAVLRotate implements AVLRotate {
	@Override
	public AVLNode rotate(AVLNode rotateNode) {
		AVLNode rootAVLSubTree = rotateNode.getRightNode();
		int value = rotateNode.getValue();
		AVLNode parentNode = rotateNode.getParentNode();
		rootAVLSubTree.setParentNode(parentNode);
		if (parentNode != null) {
			if (parentNode.getValue() > value) {
				parentNode.setLeftNode(rootAVLSubTree);
			} else {
				parentNode.setRightNode(rootAVLSubTree);
			}
		}
		
		// 调整
		rotateNode.setRightNode(rootAVLSubTree.getLeftNode());
		rootAVLSubTree.setLeftNode(rotateNode);
		
		rotateNode.setParentNode(rootAVLSubTree);
		
		return rootAVLSubTree;
	}
}

测试类

public class AVLTreeTest6 {
	public static void main(String[] args) {
		int nums[] = { 4, 1, 2, 5, 0, 7, 9, 8, 3, 6 };
		AVLNode tree = AVLTree.createAVL(nums);
		AVLLevelTraversal.traversal(tree);
	}
}

输出结果

----------------------
value=5, length=4, balanceFactor=0
value=2, length=3, balanceFactor=0
value=8, length=3, balanceFactor=1
value=1, length=2, balanceFactor=1
value=4, length=2, balanceFactor=1
value=7, length=2, balanceFactor=1
value=9, length=1, balanceFactor=0
value=0, length=1, balanceFactor=0
value=3, length=1, balanceFactor=0
value=6, length=1, balanceFactor=0

推理过程{ 4, 1, 2, 5, 0, 7, 9, 8, 3, 6 }

  • { 1, 2, 5, 0, 7, 9, 8, 3, 6 } -> 4
4
  • { 2, 5, 0, 7, 9, 8, 3, 6 } -> 1
  4
 /
1
  • { 5, 0, 7, 9, 8, 3, 6 } -> 2
  4
 /
1
 \
  2

LR旋转(412)

  2
 / \
1   4
  • { 0, 7, 9, 8, 3, 6 } -> 5
  2
 / \
1   4
     \
      5
  • { 7, 9, 8, 3, 6 } -> 0
    2
   / \
  1   4
 /     \
0       5
  • { 9, 8, 3, 6 } -> 7
    2
   / \
  1   4
 /     \
0       5
         \
          7

RR旋转(457)

    2
   / \
  1   5
 /   / \
0   4   7
  • { 8, 3, 6 } -> 9
    2
   / \
  1   5
 /   / \
0   4   7
         \
          9
  • { 3, 6 } -> 8
    2
   / \
  1   5
 /   / \
0   4   7
         \
          9
         /
        8

RR旋转(257)

      5
     / \
    2   7
   / \   \
  1   4   9
 /       /
0       8

RL旋转(798)

        5
      /   \
    2       8
   / \     / \
  1   4   7   9
 /      
0
  • { 6 } -> 3
        5
      /   \
    2       8
   / \     / \
  1   4   7   9
 /   /   
0   3
  • { } -> 6
        5
      /   \
    2       8
   / \     / \
  1   4   7   9
 /   /   /
0   3   6

层序遍历结果对比-一致

----------------------
value=5, length=4, balanceFactor=0
value=2, length=3, balanceFactor=0
value=8, length=3, balanceFactor=1
value=1, length=2, balanceFactor=1
value=4, length=2, balanceFactor=1
value=7, length=2, balanceFactor=1
value=9, length=1, balanceFactor=0
value=0, length=1, balanceFactor=0
value=3, length=1, balanceFactor=0
value=6, length=1, balanceFactor=0

核心代码说明，并轻松实现平衡二叉树删除功能

插入方法

	public static AVLNode insertAVL(AVLNode AVLNode, int value) {
		// 复用原二叉排序树功能
		AVLNode root = insert(AVLNode, value);
		// 计算平衡影子
		resetBalanceFactor(root);
		// 平衡
		root = rebalance(root);

		return root;
	}

我们可以注意到，核心方法是root = rebalance(root);方法，实现了平衡，那么我们如果实现删除后平衡如何实现，非常简单，即

	public static AVLNode deleteAVL(AVLNode AVLNode, int value) {
		// 复用原二叉排序树功能
		AVLNode root = delete(AVLNode, value);
		// 计算平衡影子
		resetBalanceFactor(root);
		// 平衡
		root = rebalance(root);
		
		return root;
	}

测试在原有基础上删除9

        5
      /   \
    2       8
   / \     / \
  1   4   7   9
 /   /   /
0   3   6

二叉排序树删除变化后

        5
      /   \
    2       8
   / \     /
  1   4   7  
 /   /   /
0   3   6

平衡旋转（LL旋转）

        5
      /   \
    2       7
   / \     / \
  1   4   6   8
 /   /  
0   3

测试类

public class AVLTreeTest {
	public static void main(String[] args) {
		int nums[] = { 4, 1, 2, 5, 0, 7, 9, 8, 3, 6 };
		AVLNode tree = AVLTree.createAVL(nums);
		AVLLevelTraversal.traversal(tree);
		
		AVLNode deleteTree = AVLTree.delete(tree, 9);
		AVLLevelTraversal.traversal(deleteTree);
	}
}

输出，预期一致

----------------------
value=5, length=4, balanceFactor=1
value=2, length=3, balanceFactor=0
value=7, length=2, balanceFactor=0
value=1, length=2, balanceFactor=1
value=4, length=2, balanceFactor=1
value=6, length=1, balanceFactor=0
value=8, length=1, balanceFactor=0
value=0, length=1, balanceFactor=0
value=3, length=1, balanceFactor=0

当然，这个原二叉排序树删除逻辑有点问题，删除节点后，还需要设置AVLNode节点的parentNode引用，这是因为我们是从二叉排序树过渡来的，修改删除代码public static AVLNode delete(AVLNode root, int value)；

添加三次设置父对象引入即可，分别是

  1. currentAVLNode.getRightNode().setParentNode(parentAVLNode);
  2. currentAVLNode.getLeftNode().setParentNode(parentAVLNode);
  3. currentMinAVLNode.setParentNode(parentAVLNode);
	public static AVLNode delete(AVLNode root, int value) {
		AVLNode isExistAVLNode = search(root, value);
		if (isExistAVLNode == null) {
			return root;
		}
		
		// 标记待删除节点的父结点，其中若删除的是根节点，则parentAVLNode为空
		AVLNode parentAVLNode = null;
		AVLNode currentAVLNode = root;
		while (currentAVLNode != null && currentAVLNode.getValue() != value) {
			parentAVLNode = currentAVLNode;
			if (currentAVLNode.getValue() > value) {
				currentAVLNode = currentAVLNode.getLeftNode();
			} else {
				currentAVLNode = currentAVLNode.getRightNode();
			}
		}
		
		// 删除，分三种情况处理
		// 1. 叶子节点
		if (currentAVLNode.getLeftNode() == null && currentAVLNode.getRightNode() == null) {
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(null);
				} else {
					parentAVLNode.setRightNode(null);
				}
			} else {
				root = null;
			}
		}
		
		// 2. 只存在一个子节点
		else if (currentAVLNode.getLeftNode() == null && currentAVLNode.getRightNode() != null) {
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(currentAVLNode.getRightNode());
				} else {
					parentAVLNode.setRightNode(currentAVLNode.getRightNode());
				}
			} else {
				root = currentAVLNode.getRightNode();
			}
			currentAVLNode.getRightNode().setParentNode(parentAVLNode);
		} 
		else if (currentAVLNode.getLeftNode() != null && currentAVLNode.getRightNode() == null) {
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(currentAVLNode.getLeftNode());
				} else {
					parentAVLNode.setRightNode(currentAVLNode.getLeftNode());
				}
			} else {
				root = currentAVLNode.getLeftNode();
			}
			currentAVLNode.getLeftNode().setParentNode(parentAVLNode);
		}
		// 3. 存在两个子节点（采用替代法-可重用代码：找出被删除节点的右子树，找出最大的结点，替换被删除的结点）
		else if (currentAVLNode.getLeftNode() != null && currentAVLNode.getRightNode() != null) {
			// 3.1  找出右子树最大节点
			AVLNode currentMinAVLNode = currentAVLNode.getRightNode();
			while (currentMinAVLNode.getLeftNode() != null) {
				currentMinAVLNode = currentMinAVLNode.getLeftNode();
			}
			// 3.2 删除右子树最大节点
			root = delete(root, currentMinAVLNode.getValue());
			// 3.3 替换待删除节点
			currentMinAVLNode.setLeftNode(currentAVLNode.getLeftNode());
			currentMinAVLNode.setRightNode(currentAVLNode.getRightNode());
			// 3.4 设置父结点子引用
			if (parentAVLNode != null) {
				if (parentAVLNode.getValue() > value) {
					parentAVLNode.setLeftNode(currentMinAVLNode);
				} else {
					parentAVLNode.setRightNode(currentMinAVLNode);
				}
			} else {
				root = currentMinAVLNode;
			}
			currentMinAVLNode.setParentNode(parentAVLNode);
		}
		
		return root;
	}

请自行验证

到这里就完成了平衡功能，接下来我们将学习红黑树

dengjili
关注
专栏目录
平衡二叉树【Java实现】
qq_45702990的博客
08-16 481
平衡二叉树的左旋转、右旋转、双旋转实现
java实现平衡二叉树
qq_45731129的博客
08-31 976
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树，可以保证查询效率较高。具有以下特点: 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。举例说明, 看看下面哪些AVL树,为什么?平衡二叉搜索树的左右子树，高度差不能大于1，所以前两个满足。...
Java实现平衡二叉树（仅含代码）
qq_41040289的博客
08-15 431
代码实现 package datastructure; import java.util.LinkedList; import java.util.Queue; public class AvlTree{ private AvlNode root; /** * 初始化平衡二叉树 * @param val 键值 */ public AvlT...
java二叉树代码实现,java 代码实现平衡二叉树
weixin_33623304的博客
03-15 169
java 代码实现平衡二叉树/*** 平衡二叉搜索(排序)树** 平衡二叉搜索树双称为AVL树，它也是一棵二叉搜索树，是对二叉搜索树的一种改进，或都是具有下列性质的二叉树：它* 的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。** 平衡因子(Balance Factor,BF)定义为该节点的左子树的深度减去其右子树的深度，则平衡二叉树上所有节点的平* 衡因子只可能是-1...
平衡二叉树的原理及java代码实现
qq_26607531的博客
05-22 211
好容易等到一个周末，本来想补上平衡二茶树的知识，但这两天一天睡觉，一天玩游戏，一转眼就到了周日夜里，想着这周不能什么事都不干，还是补完平衡二茶树再睡吧。 个人认为这一块的内容属于那种重要但不难的知识，所以，以思路分析为主，讲解为辅，相信只要大家能够按照博主的思路理一下，很容易就能理解了。 好了，以下就是纯干货环节： 要理解平衡二茶树，首先我们要从他的性质入手。这里我会从平衡二茶树两个性质着手，一步步分析出它的实现原理。 平衡二茶树是一棵二叉查找树，满足二叉查找树的所有性质。 平衡二叉树的任意节点的左右子节
【Java】平衡二叉树的实现代码
weixin_63434588的博客
06-26 291
平衡二叉搜索树（英语：Balanced Binary Tree）是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
最新发布
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
平衡二叉树详解及java代码的实现
01-19
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树（递归定义）的二叉排序树。...
java-平衡二叉树AVL的实现
04-23
在Java编程领域，平衡二叉树（特别是AVL树）是一种高效的数据结构，它通过保持树的高度平衡来确保查找、插入和删除操作的最优化。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962...
平衡二叉树的实现(java代码)
qq_22993855的博客
08-31 677
平衡二叉树的实现(java代码) 平衡二叉树引出和介绍: 平衡二叉树的创建图解过程: AVL树代码实现(java) package com.bingym.temp01.avl; public class AvlTreeDemo { /* * 平衡二叉树:AVL树:是由排序二叉树存在的一些问题导致的 * 它是一颗空树或者左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一颗平衡二叉树 * 下面的代码我们将实现通过二叉排序树===>左右旋转(或者双旋转)得到
java实现平衡二叉树（详细注释附代码）
小水牛的博客
07-11 1538
java实现平衡二叉树前言原理思路 前言 之前有用java实现排序二叉树，但实际上但插入数据较极端时，整个二叉树的左右子树会很不平衡（深度），甚至成为一个链表。平衡二叉树是一种特殊的排序二叉树，使得左右子树的深度相差不超过1，则查询节点的时间复杂度也趋于平衡。 原理 我们为平衡二叉树的每一个节点计一个平衡因子BF，则当BF的绝对值大于1，则以该节点为根的子树出现了不平衡，我们根据具体的情况对其进行相应的调整，使它回归平衡。具体情况画几张图分析： 如图，当BF=2，即左子树深度 - 右子树深度 = 2，则需
平衡二叉树java代码实现
zhongjiangYT的博客
09-09 280
平衡二叉树java代码实现 实现以下功能： 创建二叉排序树 添加结点，包含左旋，右旋，双旋转添加 查找结点 删除结点 已将各功能进行排序标号整理，防止过于杂乱。 /** * 平衡二叉树 * * @author 韩帅比 * @create 2021-09-09 17:35 */ public class AVLTreeDemo { public static void main(String[] args) { int[] arr = {10,11,7,6,8,9};
【数据结构】平衡二叉树java代码实现 构建平衡二叉树-单旋转/双旋转
y159_4的博客
02-26 228
class Node{ int value; Node left; Node right; public Node(int value) { this.value=value; } //添加节点 构建二叉排序树 public void add(Node node){ if(node==null){ return ; } //小的话放到左边 if (node....
数据结构（6）树形结构——平衡二叉树（JAVA代码实现）
Joker_ZJN的博客
11-28 1530
平衡二叉树的概念，平很二叉树的LL、RR、RL、LR旋转，以及JAVA版本的AVL树的实现。
数据结构 -- AVL平衡二叉树Java代码实现
zhangdm的博客
11-24 422
平衡二叉树
平衡二叉树完整java代码_如何使用Java来实现平衡二叉树AVL？代码详解！
weixin_39821718的博客
02-24 97
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 avlTree = ...
数据结构——平衡二叉树（Java代码实现）
共勉
05-25 959
当对一个数组[1,2,3,4,5,6,]创建排序二叉树的时候看起来更像是一个链表，这个时候就需要使用到平衡二叉树。 基本介绍 平衡二叉树也叫平衡二叉搜索树(Self-balancing binarysearchtree)又被称为AVL树，可以保证查询效率较高。 具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、 伸展树等。 二叉排序树和平衡二叉树的转化 进行左旋转. 创建一个新的节
java 平衡二叉树代码
miss_na的博客
04-23 132
说明：java使用的是值传递，如果处理不好，容易出现空指针异常 public class AVL { public AVL() { } // 插入应该一直往右边插 public Node insert(int e, Node root) { // 也就是说root在传入前必须有指向的对象 if (root == null) { root = new Node(e); return root;
平衡二叉树（java代码实现）
m0_46400910的博客
01-07 909
平衡二叉树特点 平衡二叉树就是在二叉排序树的基础上保持`平衡`:**一颗空树**或**它的左右两个子树的高度差的绝对值不超过1**，并且**左右两子树都是一颗平衡二叉树** 平衡方法 在添加完成一个树节点后，则做判断进行调整，若不平衡，则做出以下处理 1. (右子树的高度-左子树的高度) > 1 再进行判断 ①如果**它的右子树的左子树的高度大于它的右子树的右子树的高度**，则**先对右子结点进行右旋转**，**然后再对当前结点进行左旋转** 左旋转右旋转
平衡二叉树java代码
04-26
当然，我可以为您提供一个简单的平衡二叉树的Java代码： ``` public class AVLTree { public Node root; public AVLTree() { root = null; } public void insert(int key) { root = insert(root, key); } ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值