十四、平衡二叉树

1、看一个案例（说明二叉排序树可能的问题）

给你一个数列{1,2,3,4,5,6}，要求创建一棵二叉排序树（BST），并分析问题所在。

上面二叉排序树存在问题分析：

• 左子树全部为空，从形式上看，更像一个单链表
• 插入速度没有影响
• 查询速度明显降低（因为需要依次比较），不能发挥BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。
• 解决方案-平衡二叉树（AVL）

2、基本介绍

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

3、应用案例：单旋转（左旋转）

1）要求：给你一个数列，创建出对应的平衡二叉树，数列{4,3,6,5,7,8}
2）思路分析（示意图）

4、应用案例：单旋转（右旋转）

1）要求：给你一个数列，创建出对应的平衡二叉树，数列{10,12,8,9,7,6}
2）思路分析（示意图）

5、应用案例：双旋转

解决思路分析：

当符合右旋转条件时，如果它的左子树的右子树的高度大于它的左子树高度，先对当前这个节点的左节点进行旋转，在对当前节点进行右旋转的操作即可

6、完整代码

public class AVLTreeDemo {

	public static void main(String[] args) {
		AVLTree avlTree = new AVLTree();
//		int[] arr = { 4, 3, 6, 5, 7, 8 };
	        int[] arr = {10,12,8,9,7,6};
		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());
		System.out.println(avlTree.getRoot().leftHeight());
		System.out.println(avlTree.getRoot().rightHeight());
		System.out.println(avlTree.getRoot().value);
	}
}

class AVLTree {
	private Node root;

	public Node getRoot() {
		return root;
	}

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

	// 添加节点
	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) {
		this.value = value;
	}

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

	/**
	 * 查找要删除的节点
	 * 
	 * @param value 待删除的节点的值
	 * @return 如果找到，返回该节点，否则返回null
	 */
	public Node search(int value) {
		if (value == this.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);

		}
	}

	/**
	 * 查找要删除节点的父节点
	 * 
	 * @param value 待删除的节点的值
	 * @return 待删除节点的父节点，如果没有，则返回null
	 */
	public Node searchParent(int value) {
		// 如果当前节点就是要删除节点的父节点
		if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
			// 此时this就是当前节点的父节点
			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;
			}
		}
	}

	// 添加节点的方法，递归的形式进行添加节点，需要满足二叉排序树
	public void add(Node node) {
		if (node == null) {
			System.out.println("数据为空，不能判断");
			return;
		}
		// 判断传入节点的值，和当前子树根节点的关系
		if (node.value < this.value) {
			// 如果当前节点左子节点为null,直接放到左子节点即可
			if (this.left == null) {
				this.left = node;
			} else {
				// 如果左子节点不为空，直接向左边递归即可
				this.left.add(node);
			}

		} else {
			// 如果传入node.value大于等于当前节点的值,那就需要再进行判断
			// 先看右子节点是否为空
			if (this.right == null) {
				this.right = node;
			} else {
				// 递归的向右子树添加
				this.right.add(node);
			}
		}

		// 添加完了，判断是否右子树 - 左子树 >1 左旋转
		if (rightHeight() - leftHeight() > 1) {
			if (right != null && this.left.leftHeight() > this.right.rightHeight()) {
				this.rightRotate();
			} else {
				leftRotate();
			}
		}

		// 添加完节点后 如果左子树 - 右子树 > 1
		if (leftHeight() - rightHeight() > 1) {
			// 如果它的左子树的右子树高度大于它的左子树高度
			if (left != null && this.left.rightHeight() > this.left.leftHeight()) {
				this.left.leftRotate();
				rightRotate();
			} else {
				rightRotate();
			}
		}
	}

	// 中序遍历
	public void infixOrder() {
		if (this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if (this.right != null) {
			this.right.infixOrder();
		}
	}

	// 当前节点的高度
	public int height() {
		return Math.max(this.left == null ? 0 : this.left.height(), this.right == null ? 0 : this.right.height()) + 1;
	}

	// 返回左子树高度
	public int leftHeight() {
		if (this.left == null) {
			return 0;
		}
		return this.left.height();
	}

	// 返回右子树高度
	public int rightHeight() {
		if (this.right == null) {
			return 0;
		}
		return this.right.height();
	}

	// 左旋转
	public void leftRotate() {
		// 创建新的节点，以当前根节点的值
		Node newNode = new Node(this.value);
		// 把新节点的左子树设置成当前节点的左子树
		newNode.left = this.left;
		// 把新节点的右子树设置成当前节点的右子树的左子树
		newNode.right = this.right.left;
		// 把当前节点的值替换成右子树节点的值
		this.value = this.right.value;
		// 把当前节点的右子树设置成右子树的右子树
		this.right = this.right.right;
		// 把当前节点的左子树设置成新的节点
		this.left = newNode;
	}

	// 右旋转
	public void rightRotate() {
		// 创建新的节点，以当前根节点的值
		Node newNode = new Node(this.value);
		// 把新节点的右子树设置成当前节点的右子树
		newNode.right = this.right;
		// 把新节点的左子树设置成当前节点的左子树的右子树
		newNode.left = this.left.right;
		// 把当前节点的值替换为左子节点的值
		this.value = this.left.value;
		// 把当前节点的左子树设置成左子树的左子树
		this.left = this.left.left;
		// 把当前节点的右子树设置成新节点
		this.right = newNode;

	}
}