03_平衡二叉搜索树_AVL树完整版代码思路——终极版

Balanced Binary Search Tree Tree

经典常见的平衡二叉搜索树

• AVL树（取于两位发明家的名字
• 红黑树

AVL树

• 平衡因子：某节点的左右子树高度差
• AVL的特点
  • 每个节点的平衡因子只可能是 1、0、-1（绝对值 ≤ 1，如果超过 1，称之为“失衡”）
  • 每个节点的左右子树高度差不超过 1
  • 搜索、添加、删除的时间复杂度是 O(logn)

情况与解决办法有4种

• LL，即左子树的左子树，需要使用右旋转，也就是说将中间节点作为这三个节点的根节点
• RR，使用左旋转
• LR，即左子树的右子树，先变换为LL的情况，即左旋转将n节点作为第二个中间节点可以得到，再使用第一种的LL右旋转
• RL，先变换为RR的情况，即右旋转可以得到，再使用第二种的RR左旋转

1.LL的情况，右旋转

2.RR的情况，左旋转

3.LR的情况，先左旋转变成LL，再右旋转

4.RL的情况，先右旋转变成RR，再左旋转

添加导致的失衡

• 通过新添加的节点向上找parent.parent…找到最低的”失衡“节点，让它恢复平衡，整个树的高度也就平衡了（因为每一次的添加都进行平衡转换），其他父节点也就平衡了（因为导致失衡的节点就是祖先节点grandparent，即node、parent、grandparent这三代）
• 也存在一直添加都没有失衡情况发生，所以到其parent等于空时候停
• 然后判断是否平衡，即看平衡因子，如果平衡，则更新高度，否则恢复平衡

	@Override
	protected void afterAdd(Node<E> node) {
		while ((node = node.parent) != null) {
			if (isBalanced(node)) {//如果平衡，更新高度
				// 更新高度，即不用递归求左右子树高度
				((AVLNode<E>)node).updateHeight();//updateHeight(node);
			} else {
				// 恢复平衡，恢复最低的不是平衡的即可，即grandparent，所以恢复玩跳出循环
				rebalance(node);
				// 整棵树恢复平衡
				break;
			}
		}
	}

	// 该节点是否平衡，即绝对值小于等于 1
	private boolean isBalanced(Node<E> node) {
		return Math.abs(((AVLNode<E>)node).balanceFactor()) <= 1;
	}

• 由于任意一个二叉树不用存height属性，因为浪费内存，所以不可在Node类加入height属性，那么在AVL类内新添加一个类继承于Node，添加属性height
• 一开始求高度有一种方法是递归，左右子节点较高的加1，效率太低。所以在此在while循环中就做了更新高度（在while循环中顺便更新了高度，提高性能），即如果平衡了就更新高度，否则恢复平衡

	private static class AVLNode<E> extends Node<E> {
		int height = 1;//每个添加的节点都是叶子节点，所以初值为1
		
		public AVLNode(E element, Node<E> parent) {
			super(element, parent);
		}

		// 平衡因子的计算，左子树的高度减去右子树的高度
		public int balanceFactor() {
			int leftHeight = left == null ? 0 : ((AVLNode<E>)left).height;
			int rightHeight = right == null ? 0 : ((AVLNode<E>)right).height;
			return leftHeight - rightHeight;
		}
		
		// 传一个节点，更新一下高度
		public void updateHeight() {
			int leftHeight = left == null ? 0 : ((AVLNode<E>)left).height;
			int rightHeight = right == null ? 0 : ((AVLNode<E>)right).height;
			height = 1 + Math.max(leftHeight, rightHeight);
		}
		
		public Node<E> tallerChild() {
			int leftHeight = left == null ? 0 : ((AVLNode<E>)left).height;
			int rightHeight = right == null ? 0 : ((AVLNode<E>)right).height;
			if (leftHeight > rightHeight) return left;
			if (leftHeight < rightHeight) return right;
			return isLeftChild() ? left : right;
		}

• 如何判断传入节点是左子树

		public boolean isLeftChild() {
			return parent != null && this == parent.left;
		}

• 由于在实现过程中抽象出二叉树，AVL树继承二叉搜索树，而在二叉搜索树的添加方法里面，是创建一个Node节点对象，而AVL树添加节点的时候需要创建其AVLNode节点（因为包含height属性），所以在BinaryTree（二叉树类）中添加一个创建节点的方法createNode()供BST（二叉搜索树）调用，然后其添加代码由创建一个新节点改变为调用创建节点的方法实现，进而AVL树中可以重写createNode()方法，进而实现代码重用

class BinartTree{
	...
	protected Node<E> createNode(E element, Node<E> parent) {
		return new Node<>(element, parent);
	}
	...
}

//	BST类中的addNode()方法中
// 更改root = new Node<>(element, null)为下面代码
root = createNode(element, null);
// 更改Node<E> newNode = new Node<>(element, parent);
Node<E> newNode = createNode(element, parent);

// 新添加节点之后的处理，即AVL树进行的处理操作
afterAdd(root);

• AVL树中重写createNode()方法

	@Override
	protected Node<E> createNode(E element, Node<E> parent) {
		return new AVLNode<>(element, parent);
	}

• 恢复平衡：有四种方法LL、RR、LR、RL，由于传入的节点是高度最低的那个不平衡节点，所以需要找其孩子parent和孙子节点node。看上面四个图可以看到：其实parent是grand的左右子树较高的那个，node是parent左右子树高度较高的那一个

	/**
	 * 恢复平衡
	 * @param grand 高度最低的那个不平衡节点
	 */
	private void rebalance(Node<E> grand) {
		Node<E> parent = ((AVLNode<E>)grand).tallerChild();
		Node<E> node = ((AVLNode<E>)parent).tallerChild();
		if (parent.isLeftChild()) { // L
			if (node.isLeftChild()) { // LL
				rotate(grand, node, node.right, parent, parent.right, grand);
				// rotateRight(grand);
			} else { // LR  先parent左旋转再grand右旋转
				rotate(grand, parent, node.left, node, node.right, grand);
				// rotateLeft(parent);
				// rotateRight(grand);
			}
		} else { // R
			if (node.isLeftChild()) { // RL 先parent右旋转再grand左旋转
				rotate(grand, grand, node.left, node, node.right, parent);
				// rotateRight(parent);
				// rotateLeft(grand);
			} else { // RR
				rotate(grand, grand, parent.left, parent, node.left, node);
				// rotateLeft(grand);
			}
		}
	}

• 左旋转、右旋转rotateLeft(grand) 和 rotateRight(grand)
   1.更新左右left和right属性
   2.更新父节点parent属性
   3.更新grand和parent的高度

	// 左旋转即RR grand.right.right 所以 parent = grand.right
	private void rotateLeft(Node<E> grand) {
		Node<E> parent = grand.right;
		Node<E> child = parent.left;
		grand.right = child;
		parent.left = grand;
		afterRotate(grand, parent, child);
	}
	
	private void rotateRight(Node<E> grand) {
		Node<E> parent = grand.left;
		Node<E> child = parent.right;
		grand.left = child;
		parent.right = grand;
		afterRotate(grand, parent, child);
	}
	
	private void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
		/**
		 * 让 parent 成为子树的根节点 ：                              root
		 * 		a. 更新parent的parent属性                           节点1
		 * 		b. 原先grand的左右left和right需要更新	          节点2     节点3
 		 */
		// a
		parent.parent = grand.parent;
		// b
		if (grand.isLeftChild()) {                  
			grand.parent.left = parent;
		} else if (grand.isRightChild()) {
			grand.parent.right = parent;
		} else { // grand是root节点---根节点
			root = parent;
		}
		
		// 更新child的parent
		if (child != null) {
			child.parent = grand;
		}
		
		// 更新grand的parent
		grand.parent = parent;
		
		// 3.更新高度
		updateHeight(grand);
		updateHeight(parent);
	}

统一旋转操作

• 如下图，我们可以发现无论是LL、LR、RR、RL都有a < b < c < d < e < f < g，并且最终让d沉稳给根节点，而a仍是b的左节点、g仍是f的右节点。
• 所以传入b、c、d、e、f及原树的根节点即可

	private void rotate(
			Node<E> r, // 子树的根节点
			Node<E> b, Node<E> c,
			Node<E> d,
			Node<E> e, Node<E> f) {
		// 让d成为这棵子树的根节点
		d.parent = r.parent;
		if (r.isLeftChild()) {
			r.parent.left = d;
		} else if (r.isRightChild()) {
			r.parent.right = d;
		} else {
			root = d;
		}
		
		//b-c
		b.right = c;
		if (c != null) {
			c.parent = b;
		}
		updateHeight(b);
		
		// e-f
		f.left = e;
		if (e != null) {
			e.parent = f;
		}
		updateHeight(f);
		
		// b-d-f
		d.left = b;
		d.right = f;
		b.parent = d;
		f.parent = d;
		updateHeight(d);
	}

删除导致的失衡

• 可能会导致 父节点 或祖先节点 失衡（只有 1个节点会失衡）
• 恢复平衡 后，可能会导致更高层的祖先节点失【最多需要 O(logn) 次调整 】

	protected void afterRemove(Node<E> node) {
		while ((node = node.parent) != null) {
			if (isBalanced(node)) {
				// 更新高度
				((AVLNode<E>)node).updateHeight();
			} else {
				// 恢复平衡
				rebalance(node);
				// 没有break 直到根节点的失衡全都恢复为止
			}
		}
	}

总结

• 添加----afterAdd()----添加之后的处理
   可能会导致 所有 祖先节点 都失衡
   只要让高度最低的失衡节点恢复平衡，整棵树就【仅需 O(1) 次调整 】
• 删除----afterRemove()—删除之后的处理
   可能会导致 父节点 或祖先节点 失衡（只有 1个节点会失衡）
   恢复平衡 后，可能会导致更高层的祖先节点失【最多需要 O(logn) 次调整 】
• 平均时间复杂度
   搜索： O(logn)
   添加： O(logn) logn)，仅需 O(1) 次的旋转操作
   删除： O(logn) logn)，最多需要 O(logn)次的旋转操作