二叉平衡树

定义：空二叉树的高度为-1，只有根节点的二叉树高度为0，根节点在0层，深度为0。

1 二叉平衡树的定义

二叉平衡树首先是二叉排序树，其次它的左右子树的高度差不超过1.

2 二叉平衡树的插入

插入的时候，将当前节点的值和要插入的值进行比较，若小于当前节点，则进入左子树继续执行插入，如果大于当前节点，则进入右子树进行插入，如果节点为空，则生成一个新的节点，并将连接指向它 。但是这样插入以后，会出现一个问题，就是二叉树不再平衡，我们从插入后的节点向上找到的第一不平衡的节点记为α。此时α左右子树的高度差为2，这种不平衡可能出现在以下四种情况：

1. 对α的左儿子的左子树进行一次插入(LL)
2. 对α的左儿子的右子树进行一次插入(LR)
3. 对α的右儿子的左子树进行一次插入(RL)
4. 对α的右儿子的右子树进行一次插入(RR)

2.1 LL情形的处理

这种情形我们要将α的左子树向上提，这里α就是A,当我们对A的左儿子的左子树进行插入，即我们把节点插入到了BL中，这个时候，我们需要将B向上拉，然后让A指向B的右子树，再让B的右子树指向A。这个方法我们定义为左旋，可能和有的博客定义的不一样。如下图：

代码如下：

// LL插入，单左旋
	public TreeNode singleRotateWithLeft(TreeNode root) {
		TreeNode k1;
		k1 = root.left;
		root.left = k1.right;
		k1.right = root;
		root.height = height(root.left) > height(root.right) ? height(root.left) + 1 : height(root.right) + 1;
		k1.height = height(k1.left) > height(k1.right) ? height(k1.left) + 1 : height(k1.right) + 1;
		return k1;
	}

2.2 LR情形的处理

这种情形就是当我们对α节点左儿子的右子树进行了插入导致α节点失去平衡，这个时候就要进行两次旋转，一次旋转，根本就解决不了问题，首先对α节点左儿子进行右旋，然后再对α进行左旋。如下图：

代码如下：

	// LR插入，双左旋
	public TreeNode doubleRotateWithLeft(TreeNode root) {
		root.left = singleRotateWithRight(root.left);
		return singleRotateWithLeft(root);
	}

2.3 RL情形的处理

这种情形就是当我们对α节点右儿子的左子树进行了插入导致α节点失去平衡，这个时候就要进行两次旋转，一次旋转，根本就解决不了问题，首先对α节点右儿子进行左旋，然后再对α进行右旋。如下图：

代码如下：

// RL插入，双右旋
	public TreeNode doubleRotateWithRight(TreeNode root) {
		root.right = singleRotateWithLeft(root.right);
		return singleRotateWithRight(root);
	}

2.4 RR情形的处理

这种情形就是当我们对α节点右儿子的右子树进行了插入导致α节点失去平衡，这个时候进行右旋。如下图：

代码如下：

// RR插入，单右旋
	public TreeNode singleRotateWithRight(TreeNode root) {
		TreeNode k2;
		k2 = root.right;
		root.right = k2.left;
		k2.left = root;
		root.height = height(root.left) > height(root.right) ? height(root.left) + 1 : height(root.right) + 1;
		k2.height = height(k2.left) > height(k2.right) ? height(k2.left) + 1 : height(k2.right) + 1;
		return k2;
	}

PS:上面更新高度的代码顺序一定不能错，否则删除节点的时候会出现错误

3 插入

每一次插入以后，都要判断是否平衡。如果不平衡，接着进行相应的旋转。代码如下：

public TreeNode insert(int x, TreeNode node) {
		if (node == null) { // 当节点为空的时候
			node = new TreeNode(x);
			node.setLeft(null);
			node.setRight(null);
			node.setHeight(0);
		} else {// 当节点不为空的时候
			if (x < node.getVal()) {
				node.left = insert(x, node.left);
				// 判断是否平衡
				if (height(node.left) - height(node.right) == 2) {
					if (x < node.left.getVal()) {
						node = singleRotateWithLeft(node);
					} else {
						node = doubleRotateWithLeft(node);
					}
				}
			} else if (x > node.getVal()) {
				node.right = insert(x, node.right);
				// 判断是否平衡
				if (height(node.right) - height(node.left) == 2) {
					if (x > node.right.getVal()) {
						node = singleRotateWithRight(node);
					} else {
						node = doubleRotateWithRight(node);
					}
				}
			}
		}
		node.height = height(node.left) > height(node.right) ? height(node.left) + 1 : height(node.right) + 1;
		return node;
	}

树节点的定义：

public class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;
	//get..set方法
	}

获取高度的函数：

int height(TreeNode p) {
		if (p == null) {
			return -1;
		} else {
			return p.getHeight();
		}
	}

4 删除

删除操作和二叉查找树删除一样，分为三种情况讨论

（1）删除节点没有左子树，这种情况直接将删除节点的父节点指向删除节点的右子树。

（2）删除节点没有右子树，这种情况直接将删除节点的父节点指向删除节点的左子树。

（3）删除节点左右子树都存在，可以采用两种方式，

     1：让删除节点左子树的最右侧节点代替当前节点
     2：让删除节点右子树的最左侧节点代替当前节点

删除很简单，难的是删除以后要进行调整，调整也是通过上面的旋转来进行调整，比如给定一个节点A，如果我们对它的子树进行了删除导致不平衡，如果删除了A左子树中的节点，那就要对右子树进行调整，因为删除左子树就相当于是对右子树进行了添加。具体代码如下：

// 删除任意节点，删除的以后哟啊保持平衡
	public TreeNode delete(TreeNode node, int x) {

		if (node == null) {
			return null; // 当当前节点为空的时候，返回空
		}
		if (x < node.getVal()) { //小于当前节点的时候，向左子树中进行查找删除
			node.left = delete(node.left, x);
		} else if (x > node.getVal()) {//当大于当前节点的时候，向右子树中进行查找删除
			node.right = delete(node.right, x);
		} else {  //当等于当前节点的时候进行删除
			if (node.left == null) {
				return node.right;
			} else if (node.right == null) {
				return node.left;
			} else {
				// 当要删除节点的左右子树都不 为空的情况下
				// 首先找到当前节点右子树中的最小节点
				TreeNode minNode = findMin(node);
				// 把这个值直接赋给要删除节点 ，然后把那个最小值对应的节点给删除
				node.setVal(minNode.getVal());
				node.right = delete(node.right, minNode.getVal());
			}

		}
		// 接下来进行判断是否平衡,首先更新高度

		node.height = height(node.left) > height(node.right) ? height(node.left) + 1 : height(node.right) + 1;
		// 进行调整
		if (height(node.left) - height(node.right) > 1) {
			// 当左子树比右子树高的时候，此时删除的是右子树中的节点，需要对左子树进行调整，这又分为两种情况，
			//一种是左子树的左子树高度比同一级的右子树高，此时进行单左旋，否则就进行双左旋
			if (height(node.left.left) - height(node.left.right) >= 0) {
				node = singleRotateWithLeft(node);
			} else {
				node = doubleRotateWithLeft(node);
			}
		} else if (height(node.left) - height(node.right) < -1) {
			// 右子树比左子树高的时候，此时删除的是左子树中的节点，需要最右子树进行调整，这也分为两种情况，
			//一种是右子树的左子树比和它同一级的右子树高，此时进行双右旋，否则进行单左旋

			if (height(node.right.left) - height(node.right.right) <= 0) {
				node = singleRotateWithRight(node);
			} else {
				node = doubleRotateWithRight(node);
			}
		}
		return node;
	}

	// 查找二叉搜索树中的最小值节点,一直往左子树中找
	public TreeNode findMin(TreeNode node) {
		if (node == null) {
			return null;
		} else {
			if (node.left == null) {
				return node;
			} else {
				return findMin(node.left);
			}
		}
	}