AVL树

AVL树的介绍

　　AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

　　上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。

　　如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种情况：LL(左左)，LR(左右)，RR(右右)和RL(右左)。下面给出它们的示意图：

　　上图中的4棵树都是'失去平衡的AVL树'，从左往右的情况依次是：LL、LR、RL、RR。除了上面的情况之外，还有其它的失去平衡的AVL树，如下图：

　　上面的两张图都是为了便于理解，而列举的关于'失去平衡的AVL树'的例子。总的来说，AVL树失去平衡时的情况一定是LL、LR、RL、RR这4种之一，它们都由各自的定义：

　　(1) LL：LeftLeft，也称为'左左'。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致'根的左子树的高度'比'根的右子树的高度'大2，导致AVL树失去了平衡。

　　(2) LR：LeftRight，也称为'左右'。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致'根的左子树的高度'比'根的右子树的高度'大2，导致AVL树失去了平衡。

　　(3) RL：RightLeft，称为'右左'。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致'根的右子树的高度'比'根的左子树的高度'大2，导致AVL树失去了平衡

　　(4) RR：RightRight，称为'右右'。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致'根的右子树的高度'比'根的左子树的高度'大2，导致AVL树失去了平衡。
　　如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。AVL失去平衡之后，可以通过旋转使其恢复平衡，下面分别介绍'LL(左左)，LR(左右)，RR(右右)和RL(右左)'这4种情况对应的旋转方法。

2.1 LL的旋转

　　LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：

　　图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。对于LL旋转，你可以这样理解为：LL旋转是围绕'失去平衡的AVL根节点'进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着'左孩子，即k1'使劲摇。将k1变成根节点，k2变成k1的右子树，'k1的右子树'变成'k2的左子树'。LL的旋转代码如下：

private static AvlNode rotateWithLeftChild(AvlNode k2) {
	AvlNode k1 = k2.left;
	k2.left = k1.right;
	k1.right = k2;
	k2.height = max(height(k2.left), height(k2.right)) + 1;
	k1.height = max(height(k1.left), k2.height) + 1;
	return k1;
}

2.2 RR的旋转

　　理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：

　　图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。RR的旋转代码如下:

private static AvlNode rotateWithRightChild(AvlNode k1) {
	AvlNode k2 = k1.right;
	k1.right = k2.left;
	k2.left = k1;
	k1.height = max(height(k1.left), height(k1.right)) + 1;
	k2.height = max(height(k2.right), k1.height) + 1;
	return k2;
}

2.3 LR的旋转

　　LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。如下图：

　　第一次旋转是围绕'k1'进行的'RR旋转'，第二次是围绕'k3'进行的'LL旋转'。LR的旋转代码:

private static AvlNode doubleWithLeftChild(AvlNode k3) {
	k3.left = rotateWithRightChild(k3.left);
	return rotateWithLeftChild(k3);
}

2.4 RL的旋转

　　RL是与LR的对称情况！RL恢复平衡的旋转方法如下：

　　第一次旋转是围绕'k3'进行的'LL旋转'，第二次是围绕'k1'进行的'RR旋转'。

private static AvlNode doubleWithRightChild(AvlNode k1) {
	k1.right = rotateWithLeftChild(k1.right);
	return rotateWithRightChild(k1);
}

3. 插入

　　插入节点的代码

private AvlNode insert(Comparable x, AvlNode t) {
	if (t == null)
		t = new AvlNode(x, null, null);
	else if (x.compareTo(t.element) < 0) {
		t.left = insert(x, t.left);
		if (height(t.left) - height(t.right) == 2)
			if (x.compareTo(t.left.element) < 0)
				t = rotateWithLeftChild(t);
			else
				t = doubleWithLeftChild(t);
	} else if (x.compareTo(t.element) > 0) {
		t.right = insert(x, t.right);
		if (height(t.right) - height(t.left) == 2)
			if (x.compareTo(t.right.element) > 0)
				t = rotateWithRightChild(t);
			else
				t = doubleWithRightChild(t);
	} else
		;
	t.height = max(height(t.left), height(t.right)) + 1;
	return t;
}
public void insert(Comparable x) {
	root = insert(x, root);
}

4. 删除

　　删除节点的代码:

private AvlNode remove(AvlNode tree, AvlNode z) {
	//根为空或者没有要删除的节点，直接返回null。
	if (tree == null || z == null)
		return null;
	int cmp = z.element.compareTo(tree.element);
	if (cmp < 0) { //待删除的节点在'tree的左子树'中
		tree.left = remove(tree.left, z);
		//删除节点后，若AVL树失去平衡，则进行相应的调节。
		if (height(tree.right) - height(tree.left) == 2) {
			AvlNode r = tree.right;
			if (height(r.left) > height(r.right))
				tree = doubleWithRightChild(tree);
			else
				tree = rotateWithRightChild(tree);
		}
	} else if (cmp > 0) { // 待删除的节点在'tree的右子树'中
		tree.right = remove(tree.right, z);
		// 删除节点后，若AVL树失去平衡，则进行相应的调节。
		if (height(tree.left) - height(tree.right) == 2) {
			AvlNode l = tree.left;
			if (height(l.right) > height(l.left))
				tree = doubleWithLeftChild(tree);
			else
				tree = rotateWithLeftChild(tree);
		}
	} else { // tree是对应要删除的节点。
		// tree的左右孩子都非空
		if ((tree.left != null) && (tree.right != null)) {
			if (height(tree.left) > height(tree.right)) {
			        // 如果tree的左子树比右子树高；
			        // 则(01)找出tree的左子树中的最大节点
			        // (02)将该最大节点的值赋值给tree。
			        // (03)删除该最大节点。
			        // 这类似于用'tree的左子树中最大节点'做'tree'的替身；
			        // 采用这种方式的好处是：删除'tree的左子树中最大节点'之后，AVL树仍然是平衡的。
				AvlNode max = findMax(tree.left);
				tree.element = max.element;
				tree.left = remove(tree.left, max);
			} else {
				// 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
				// 则(01)找出tree的右子树中的最小节点
				// (02)将该最小节点的值赋值给tree。
				// (03)删除该最小节点。
				// 这类似于用'tree的右子树中最小节点'做'tree'的替身；
				// 采用这种方式的好处是：删除'tree的右子树中最小节点'之后，AVL树仍然是平衡的。
				AvlNode min = findMin(tree.right);
				tree.element = min.element;
				tree.right = remove(tree.right, min);
			}
		} else {
			AvlNode tmp = tree;
			tree = (tree.left != null) ? tree.left : tree.right;
			tmp = null;
		}
	}
	return tree;
}
public void remove(Comparable key) {
	AvlNode z;
	if ((z = find(key, root)) != null)
		root = remove(root, z);
}

完整的实现

　　1.AVLNode节点的实现。

class AvlNode{
	// Constructors
	AvlNode(Comparable theElement) {
		this(theElement, null, null);
	}
	AvlNode(Comparable theElement, AvlNode lt, AvlNode rt) {
		element = theElement;
		left = lt;
		right = rt;
		height = 0;
	}
	// Friendly data; accessible by other package routines
	Comparable element; // The data in the node
	AvlNode left; // Left child
	AvlNode right; // Right child
	int height; // Height
}

 　　2.AVLTree的实现

public class AvlTree {
	private AvlNode root;// The tree root

	public AvlTree() {
		root = null;
	}

	public void insert(Comparable x) {
		root = insert(x, root);
	}

	public Comparable findMin() {
		return elementAt(findMin(root));
	}

	public Comparable findMax() {
		return elementAt(findMax(root));
	}

	public Comparable find(Comparable x) {
		return elementAt(find(x, root));
	}

	public void makeEmpty() {
		root = null;
	}

	public boolean isEmpty() {
		return root == null;
	}

	public void printTree() {
		if (isEmpty())
			System.out.println("Empty tree");
		else
			printTree(root);
	}

	private Comparable elementAt(AvlNode t) {
		return t == null ? null : t.element;
	}

	private AvlNode insert(Comparable x, AvlNode t) {
		//如上
	}

	private AvlNode findMin(AvlNode t) {
		if (t == null)
			return t;
		while (t.left != null)
			t = t.left;
		return t;
	}

	private AvlNode findMax(AvlNode t) {
		if (t == null)
			return t;
		while (t.right != null)
			t = t.right;
		return t;
	}

	private AvlNode find(Comparable x, AvlNode t) {
		while (t != null)
			if (x.compareTo(t.element) < 0)
				t = t.left;
			else if (x.compareTo(t.element) > 0)
				t = t.right;
			else
				return t; // Match
		return null; // No match
	}

	private void printTree(AvlNode t) {
		if (t != null) {
			printTree(t.left);
			System.out.println(t.element);
			printTree(t.right);
		}
	}

	private static int height(AvlNode t) {
		return t == null ? -1 : t.height;
	}

	private static int max(int lhs, int rhs) {
		return lhs > rhs ? lhs : rhs;
	}

	private static AvlNode rotateWithLeftChild(AvlNode k2) {
		//如上
	}

	private static AvlNode rotateWithRightChild(AvlNode k1) {
		//如上
	}

	private static AvlNode doubleWithLeftChild(AvlNode k3) {
		k3.left = rotateWithRightChild(k3.left);
		return rotateWithLeftChild(k3);
	}

	private static AvlNode doubleWithRightChild(AvlNode k1) {
		k1.right = rotateWithLeftChild(k1.right);
		return rotateWithRightChild(k1);
	}

	private AvlNode remove(AvlNode tree, AvlNode z) {
		//如上
	}
	public void remove(Comparable key) {
		AvlNode z;
		if ((z = find(key, root)) != null)
			root = remove(root, z);
	}
	// Test program
	public static void main(String[] args) {
		AvlTree t = new AvlTree();
		final int NUMS = 4000;
		final int GAP = 37;

		System.out.println("Checking... (no more output means success)");

		for (int i = GAP; i != 0; i = (i + GAP) % NUMS)
			t.insert(new MyInteger(i));

		if (NUMS < 40)
			t.printTree();
		if (((MyInteger) (t.findMin())).intValue() != 1
				|| ((MyInteger) (t.findMax())).intValue() != NUMS - 1)
			System.out.println("FindMin or FindMax error!");

		for (int i = 1; i < NUMS; i++)
			if (((MyInteger) (t.find(new MyInteger(i)))).intValue() != i)
				System.out.println("Find error1!");
	}
}

 构建AVL

　　2. 依次添加'3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9' 到AVL树中。

　　2.01 添加3,2
　　添加3,2都不会破坏AVL树的平衡性。

　　2.02 添加1
　　添加1之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：

　　2.03 添加4
　　添加4不会破坏AVL树的平衡性。

　　2.04 添加5
　　添加5之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：

　　2.05 添加6
　　添加6之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：

　　2.06 添加7
　　添加7之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：

　　2.07 添加16
　　添加16不会破坏AVL树的平衡性。

　　2.08 添加15
　　添加15之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：

　　2.09 添加14
　　添加14之后，AVL树失去平衡(RL)，此时需要对AVL树进行旋转(RL旋转)。旋转过程如下：

　　2.10 添加13
　　添加13之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：

　　2.11 添加12
　　添加12之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：

　　2.12 添加11
　　添加11之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：

　　2.13 添加10
　　添加10之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：

　　2.14 添加8
　　添加8不会破坏AVL树的平衡性。

　　2.15 添加9
　　但是添加9之后，AVL树失去平衡(LR)，此时需要对AVL树进行旋转(LR旋转)。旋转过程如下：

　　3. 打印树的信息

　　输出下面树的信息：

　　前序遍历: 7 4 2 1 3 6 5 13 11 9 8 10 12 15 14 16 
　　中序遍历: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
　　后序遍历: 1 3 2 5 6 4 8 10 9 12 11 14 16 15 13 7 
　　高度: 5
　　最小值: 1
　　最大值: 16

　　4. 删除节点8

　　删除操作并不会造成AVL树的不平衡。

　　删除节点8之后，再打印该AVL树的信息。
　　高度: 5
　　中序遍历: 1 2 3 4 5 6 7 9 10 11 12 13 14 15 16