ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

平衡二叉树

2022-08-22 09:06:26  阅读:145  来源: 互联网

标签:左子 结点 right 右子 二叉树 平衡 null left


1.为什么需要平衡二叉树?

二叉排序树可能的存在的问题

给你一个数列{1,2,3,4,5,6},要求创建一颗二叉排序树(BST), 并分析问题所在.

1661085324274

上图BST存在的问题分析:

  1. 左子树全部为空,从形式上看,更像一个单链表。
  2. 插入速度没有影响
  3. 查询速度明显降低(因为需要依次比较), 不能发挥BST的优势,因为每次还需要比较左子树,其查询速度比单链表还慢

上面问题怎么解决呢?

解决方案-平衡二叉树(AVL)

2.平衡二叉树基本介绍

  1. 平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树, 可以保证查询效率较高
  2. 具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
  3. 举例说明, 看看下面哪些AVL树

1661085870828

3.AVL高度求解

3.1代码结构

1661088526263

3.2代码实现

// 返回左子树的高度
	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;
	}

3.3测试代码

public static void main(String[] args) {
		int[] arr = {4,3,6,5,7,8};
		//创建一个AVLTree对象
		AVLTree avlTree = new AVLTree();
		//添加结点
		for(int i = 0; i<arr.length; i++){
			avlTree.add(new Node(arr[i]));
		}
		
		//中序遍历
		System.out.println("中序遍历之后");
		avlTree.infixOrder();
		
		System.out.println("没有平衡之前=====");
		System.out.println("树的高度=" + avlTree.getRoot().height());//4
		System.out.println("树的左子树高度=" + avlTree.getRoot().leftHeight());//1
		System.out.println("树的右子树高度=" + avlTree.getRoot().rightHeight());//3
		

	}

3.4测试结果

1661088716387

4.AVL实现左旋转

4.0图解

1661089294231

4.1代码结构

1661090728311

4.2代码实现

// 左旋转方法
	public void leftRotate() {
		//创建新的结点,以当前根结点的值
		Node newNode = new Node(value);
		//把新的结点的左子树设置成当前结点的左子树
		newNode.left = left;
		//把新结点的右子树设置成当前结点的右子结点的左子树
		newNode.right = right.left;
		//把当前结点的值替换成当前结点的右子结点的值
		value = right.value;
		//把当前结点的右子树设置成当前结点的右子树的右子树
		right = right.right;//相当于跳过一个结点
		//把当前结点的左子树(左子结点)设置成新的结点
		left = newNode;		
	}

需要在add()方法中调用旋转方法

// 编写增加结点的方法
	public void add(Node node) {
		if (node == null) {
			return;
		}
		// 判断当前结点与左右子树值的大小关系
		if (node.value < this.value) {
			// 左子树的值小,向左子树增加
			if (this.left == null) {
				// 左子树为空,直接添加
				this.left = node;
			} else {
				// 左子树不为空,向左子树增加
				this.left.add(node);
			}
		} else {
			// 传入的node结点的值大于当前结点,增加到右子树
			if (this.right == null) {
				this.right = node;
			} else {
				// 递归增加到右子树
				this.right.add(node);
			}
		}
		
		//当添加完一个结点之后,如果 (右子树的高度-左子树的高度)> 1,则左旋转
		if (rightHeight() - leftHeight() > 1) {
			
			leftRotate();//左旋转
		}

	}

4.3测试代码和结果

1661090874372

5.AVL实现右旋转

5.0图解

1661091877130

5.1代码结构

1661091952536

5.2代码实现

//右旋转方法
	public void rightRotate(){
		//1.创建一个新结点newNode,新结点的值等于当前结点的值
		Node newNode = new Node(value);
		//2.把新结点的右子树设置成当前结点的右子树
		newNode.right = right;
		//3.把新结点的左子树设置成当前结点的左子树的右子树
		newNode.left = left.right;
		//4.把当前结点的值换成当前结点的左子结点
		value = left.value;
		//5.把当前结点的左子树设置成左子树的左子树
		left = left.left;
		//6.把当前结点的右子树设置成新结点(难)
		right = newNode;
	}

需要在add()方法中调用旋转方法

// 当添加完一个结点之后,如果 (左子树的高度-右子树的高度)> 1,则右旋转
		if (leftHeight() - rightHeight()  > 1) {

			rightRotate();// 右旋转
		}

5.3测试代码和结果

旋转前

1661092146069

旋转后

1661092310109

6.AVL实现双旋转

6.0图解

1661092496805

上面右旋转之后问题没有得到解决

问题分析

1.当符合右旋转的条件时
2.如果它的左子树的右子树高度大于它的左子树的高度

3.先对当前这个结点的左节点进行左旋转
4.再对当前结点进行右旋转的操作即可

6.1代码结构

1661093723951

6.2代码实现

// 编写增加结点的方法
	public void add(Node node) {
		if (node == null) {
			return;
		}
		// 判断当前结点与左右子树值的大小关系
		if (node.value < this.value) {
			// 左子树的值小,向左子树增加
			if (this.left == null) {
				// 左子树为空,直接添加
				this.left = node;
			} else {
				// 左子树不为空,向左子树增加
				this.left.add(node);
			}
		} else {
			// 传入的node结点的值大于当前结点,增加到右子树
			if (this.right == null) {
				this.right = node;
			} else {
				// 递归增加到右子树
				this.right.add(node);
			}
		}
		
		//当添加完一个结点之后,如果 (右子树的高度-左子树的高度)> 1,则左旋转
		if (rightHeight() - leftHeight() > 1) {
			// 如果它的右子树的左子树的高度大于它的右子树的高度
			if (right != null && right.leftHeight() > right.rightHeight()) {
				// 先对当前结点的右节点(右子树)进行右旋转
				right.rightRotate();
				// 再对当前结点进行左旋转
				leftRotate();
			} else {
				// 直接左旋转
				leftRotate();
			}
			return;//必须要
		}
		
		// 当添加完一个结点之后,如果 (左子树的高度-右子树的高度)> 1,则右旋转
		if (leftHeight() - rightHeight()  > 1) {
			// 如果它的左子树的右子树的高度大于它的左子树的高度
			if (left != null && left.rightHeight() > left.leftHeight()) {
				//先对当前结点的左节点(左子树)进行左旋转
				left.leftRotate();
				//再对当前结点进行右旋转
				rightRotate();
			} else {
				//直接右旋转
				rightRotate();
			}
		}
        
    }

6.3测试

1661127313865

7.代码汇总

public class AVLTreeDemo {

	public static void main(String[] args) {
//		int[] arr = {4,3,6,5,7,8};
//		int[] arr = {10,1,8,9,7,6};
		int[] arr = {10,11,7,8,8,9};
		//创建一个AVLTree对象
		AVLTree avlTree = new AVLTree();
		//添加结点
		for(int i = 0; i<arr.length; i++){
			avlTree.add(new Node(arr[i]));
		}
		
		//中序遍历
		System.out.println("中序遍历之后");
		avlTree.infixOrder();
		
		System.out.println("平衡之后=====");
		System.out.println("树的高度=" + avlTree.getRoot().height());//3
		System.out.println("树的左子树高度=" + avlTree.getRoot().leftHeight());//2
		System.out.println("树的右子树高度=" + avlTree.getRoot().rightHeight());//2
		
		
		

	}

}

// 创建AVLTree
class AVLTree {
	private Node root;

	
	public Node getRoot() {
		return root;
	}

	public void setRoot(Node root) {
		this.root = root;
	}

	// 编写一个返回要删除结点右子树的最大值
	/**
	 * 
	 * @param node
	 *            传入的结点(当做二叉排序树的根结点)
	 * @return 返回以node为根结点的二叉排序树的最小结点的值
	 */
	public int delRightTreeMin(Node node) {
		Node target = node;
		// 循环的查找左子结点,就会找到最小值
		while (target.left != null) {
			target = target.left;
		}
		// 找到最小值之后,删除最小值
		delNode(target.value);
		// 此时target还是指向最小值结点的
		return target.value;
	}

	// 删除结点
	public void delNode(int value) {
		if (root == null) {
			return;
		} else {
			// 1.先查找要删除的结点
			Node targetNode = search(value);
			// 如果没有找到要删除的结点
			if (targetNode == null) {
				return;
			}
			// 如果发现当前这棵二叉排序树只有一个结点(特例,只有更结点)
			if (root.left == null && root.right == null) {
				root = null;
				return;
			}

			// 2.找到targetNode的父结点
			Node 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.right != null && targetNode.left != null) {
				// 删除有两棵子树的结点
				int minVal = delRightTreeMin(targetNode.right);
				targetNode.value = minVal;

			} else {// 删除只有一棵子树的结点

				if (targetNode.left != null) {// 如果删除的结点有左子结点
					if (parent != null) {
						// 如果targrtNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.left;
						} else {// 如果targrtNode 是 parent 的右子结点
							parent.right = targetNode.left;
						}
					} else {
						root = targetNode.left;
					}

				} else {// 如果删除的结点有右子结点
					if (parent != null) {
						// 如果targrtNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.right;
						} else {// 如果targrtNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					} else {
						root = targetNode.right;
					}
				}
			}
		}
	}

	// 查找要删除的结点
	public Node search(int value) {
		if (root == null) {
			return null;
		} else {
			return root.search(value);
		}
	}

	// 查找要删除结点的父结点
	public Node searchParent(int value) {
		if (root == null) {
			return null;
		} else {
			return root.searchParent(value);
		}
	}

	// 添加结点方法
	public void add(Node node) {
		if (root == null) {
			root = node;
		} else {
			root.add(node);
		}
	}

	// 中序遍历
	public void infixOrder() {
		if (root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空,不能遍历");
		}
	}
}

// 第一,创建结点信息
class Node {
	int value;
	Node left;
	Node right;

	public Node(int value) {
		super();
		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;
	}
	
	// 左旋转方法
	public void leftRotate() {
		//创建新的结点,以当前根结点的值
		Node newNode = new Node(value);
		//把新的结点的左子树设置成当前结点的左子树
		newNode.left = left;
		//把新结点的右子树设置成当前结点的右子结点的左子树
		newNode.right = right.left;
		//把当前结点的值替换成当前结点的右子结点的值
		value = right.value;
		//把当前结点的右子树设置成当前结点的右子树的右子树
		right = right.right;//相当于跳过一个结点
		//把当前结点的左子树(左子结点)设置成新的结点
		left = newNode;		
	}
	
	//右旋转方法
	public void rightRotate(){
		//1.创建一个新结点newNode,新结点的值等于当前结点的值
		Node newNode = new Node(value);
		//2.把新结点的右子树设置成当前结点的右子树
		newNode.right = right;
		//3.把新结点的左子树设置成当前结点的左子树的右子树
		newNode.left = left.right;
		//4.把当前结点的值换成当前结点的左子结点
		value = left.value;
		//5.把当前结点的左子树设置成左子树的左子树
		left = left.left;
		//6.把当前结点的右子树设置成新结点(难)
		right = newNode;
	}

	@Override
	public String toString() {
		return "Node [value=" + value + "]";
	}

	// 编写查找需要删除结点的父结点
	/**
	 * 
	 * @param value
	 *            要查找的结点值
	 * @return 返回的是要删除结点的父结点,如果没有就返回null
	 */
	public Node 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;// 没有找到父结点
			}
		}

	}

	// 编写查找要删除的结点
	/**
	 * 
	 * @param value
	 *            需要删除的结点
	 * @return 如果找到则返回该结点,否则返回null
	 */
	public Node search(int value) {
		if (this.value == value) {
			// 找到删除的结点,返回
			return this;
		} else if (value < this.value) {
			// 如果查找的结点值小于当前结点,向左子树递归查找
			// 注意,判断左子结点是否为空
			if (this.left == null) {
				return null;// 没有找到
			}
			return this.left.search(value);
		} else {
			// 如果查找的结点值大于当前结点,向右子树递归查找
			// 注意,判断右子结点是否为空
			if (this.right == null) {
				return null;// 没有找到
			}
			return this.right.search(value);
		}

	}

	// 编写中序遍历方法(前序,后序遍历复习前面的)
	public void infixOrder() {
		if (this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if (this.right != null) {
			this.right.infixOrder();
		}

	}

	// 编写增加结点的方法
	public void add(Node node) {
		if (node == null) {
			return;
		}
		// 判断当前结点与左右子树值的大小关系
		if (node.value < this.value) {
			// 左子树的值小,向左子树增加
			if (this.left == null) {
				// 左子树为空,直接添加
				this.left = node;
			} else {
				// 左子树不为空,向左子树增加
				this.left.add(node);
			}
		} else {
			// 传入的node结点的值大于当前结点,增加到右子树
			if (this.right == null) {
				this.right = node;
			} else {
				// 递归增加到右子树
				this.right.add(node);
			}
		}
		
		//当添加完一个结点之后,如果 (右子树的高度-左子树的高度)> 1,则左旋转
		if (rightHeight() - leftHeight() > 1) {
			// 如果它的右子树的左子树的高度大于它的右子树的高度
			if (right != null && right.leftHeight() > right.rightHeight()) {
				// 先对当前结点的右节点(右子树)进行右旋转
				right.rightRotate();
				// 再对当前结点进行左旋转
				leftRotate();
			} else {
				// 直接左旋转
				leftRotate();
			}
			return;//必须要
		}
		
		// 当添加完一个结点之后,如果 (左子树的高度-右子树的高度)> 1,则右旋转
		if (leftHeight() - rightHeight()  > 1) {
			// 如果它的左子树的右子树的高度大于它的左子树的高度
			if (left != null && left.rightHeight() > left.leftHeight()) {
				//先对当前结点的左节点(左子树)进行左旋转
				left.leftRotate();
				//再对当前结点进行右旋转
				rightRotate();
			} else {
				//直接右旋转
				rightRotate();
			}
			
		}

	}

}

标签:左子,结点,right,右子,二叉树,平衡,null,left
来源: https://www.cnblogs.com/y-tao/p/16611645.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有