平衡二叉树

一.前沿

二叉排序树(又叫二叉搜索树)：左子树上的所有节点的值均小于根节点值，而右子树上所有节点的值均大于根节点的值。

平衡二叉树也是一种二叉排序树，同时保证左右子树的高度差小于大于1，避免了二叉搜索树”链表化“。

二.平衡二叉树

先按照生成二叉搜索树的方法构造二叉树，直至二叉树变得不平衡，即出现这样的节点：左子树与右子树的高度差大于1。至于如何调整，要看插入的导致二叉树不平衡的节点的位置。主要有四种调整方式：LL（左旋）、RR（右旋）、LR（先左旋再右旋）、RL（先右旋再左旋）。

1.左旋

红色节点为插入后不平衡的节点，黄色部分为需要改变父节点的分支，左旋后，原红色节点的右孩子节点变成了根节点，红色节点变成了它的左孩子，而它原本的左孩子（黄色部分）不能丢，而此时红色节点的右孩子是空的，于是就把黄色部分放到了红色节点的右孩子的位置上。调整后该二叉树还是一棵二叉排序（搜索）树，因为黄色部分的值大于原来的根节点的值，而小于后来的根节点的值，调整后，黄色部分还是位于原来的根节点（红色节点）和后来的根节点之间。

2.右旋

红色节点为插入后不平衡的节点，黄色部分为需要改变父节点的分支，右旋后，原红色节点的左孩子节点变成了根节点，红色节点变成了它的右孩子，而它原本的右孩子（黄色部分）不能丢，而此时红色节点的左孩子是空的，于是就把黄色部分放到了红色节点的左孩子的位置上。调整后该二叉树还是一棵二叉排序（搜索）树，因为黄色部分的值小于原来的根节点的值，而大于后来的根节点的值，调整后，黄色部分还是位于后来的根节点和原来的根节点（红色节点）之间。

3.左右旋

先将红色节点的左子树左旋，红色节点的左子树的根原本是值为4的节点，左旋后变为值为6的节点，原来的根节点变成了左旋后根节点的左孩子，左旋后根节点原本的左孩子（蓝色节点）变成了原来的根节点的右孩子；再整体右旋，原来的根节点（红色节点）变成了右旋后的根节点的右孩子，右旋后的根节点原本的右孩子（黄色节点）变成了原来的根节点（红色节点）的左孩子。旋转完成后，仍然是一棵二叉排序（搜索）树。

4.右左旋

与左右旋转类似，

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

struct node // 二叉树节点声明
{
	int val;
	node *left;
	node *right;
	node(int v) :
		val(v), left(nullptr), right(nullptr) {}
	node() {}
};

int depth(node *root) { //求树的高度
	if (root == nullptr) {
		return 0;
	}
	int dep1 = depth(root->left);
	int dep2 = depth(root->right);
	return ((dep1 > dep2) ? dep1 : dep2) + 1;
}

node *LeftRotate(node *root) { // 左旋
	node *temp = root->right;
	root->right = temp->left;
	temp->left = root;
	return temp;
}

node *RightRotate(node *root) { // 右旋转
	node *temp = root->left;
	root->left = temp->right;
	temp->right = root;
	return temp;
}

node *LeftRightRotate(node *root) { // 先左旋后右旋
	root->left = LeftRotate(root->left);
	return RightRotate(root);
}

node *RightLeftRotate(node *root) { // 先右旋后左旋
	root->right = RightRotate(root->right);
	return LeftRotate(root);
}

node *Insert(node *root, int v) { // 插入节点的操作
	if (root == nullptr) {
		root = new node();
		root->val = v;
		root->left = nullptr;
		root->right = nullptr;
	}
	else {
		if (v < root->val) {
			// 插入到左子树中
			root->left = Insert(root->left, v);
			if (depth(root->left) - depth(root->right) >= 2) {
				//左边高
				if (v < root->left->val) {
					//右旋
					root = RightRotate(root);
				}
				else {
					//先左旋后右旋
					root = LeftRightRotate(root);
				}
			}
		}
		else {
			//插入到右子树中
			root->right = Insert(root->right, v);
			if (depth(root->right) - depth(root->left) >= 2) {
				if (v > root->right->val) {
					// 左旋
					root = LeftRotate(root);
				}
				else {
					// 先右选后左旋
					root = RightLeftRotate(root);
				}
			}
		}
	}
	return root;
}

vector<int> PrintFromTopToBottom(node *root) {
	vector<int> res;
	if (root == nullptr) {
		return res;
	}
	queue<node*> q;
	q.push(root);
	while (!q.empty()) {
		node *temp = q.front();
		q.pop();
		res.push_back(temp->val);
		if (temp->left != nullptr) {
			q.push(temp->left);
		}
		if (temp->right != nullptr) {
			q.push(temp->right);
		}
	}
	return res;
}

vector<vector<int>> PrintFromTopToBottomWithZ(node *root){
	vector<vector<int>> ret;
	if (!root) return ret;
	queue<node *> q;
	q.push(root);
	int level = 0;
	while (!q.empty()) {
		int sz = q.size();
		vector<int> ans;
		while (sz--) {
			node *temp = q.front();
			q.pop();
			ans.push_back(temp->val);

			if (temp->left) q.push(temp->left);
			if (temp->right) q.push(temp->right);
		}
		++level;
		if (!(level & 1)) {// 偶数层
			reverse(ans.begin(), ans.end());
		}
		ret.push_back(ans);
	}
	return ret;
}

void printVectorResult(const vector<int> res) {
	for (vector<int>::const_iterator it = res.begin(); it != res.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	node *tree = new node(6);
	tree = Insert(tree, 5);
	tree = Insert(tree, 4);
	tree = Insert(tree, 3);
	tree = Insert(tree, 2);
	tree = Insert(tree, 1);
	tree = Insert(tree, 0);

	vector<int> res = PrintFromTopToBottom(tree);
 	printVectorResult(res);
	return 0;
}