首先定义节点：

#include<stdio.h>
#include<stdlib.h>
#include<cstring>

class Node
{
public:
	Node(int d);
	Node(Node* other);
	int data;
	int height;
	int distance;
	Node* leftChild;
	Node* rightChild;
	Node* father;
	int calculateDistance();
	int calculateheight();
};

Node::Node(int d)
{
	this->data = d;
	father = NULL;
	leftChild = NULL;
	rightChild = NULL;
	height = 1;
	distance = 0;
}

Node::Node(Node* other)
{
	this->data = other->data;
	this->distance = other->distance;
	this->father = other->father;
	this->height = other->height;
	this->leftChild = other->leftChild;
	this->rightChild = other->rightChild;
}

int Node::calculateDistance()
{
	int leftHeight;
	int rightHeight;

	leftHeight = leftChild == NULL? 0 : leftChild->height;
	rightHeight = rightChild == NULL? 0 : rightChild->height;

	return leftHeight-rightHeight;
}

int Node::calculateheight()
{
	int leftHeight;
	int rightHeight;

	leftHeight = leftChild == NULL? 0 : leftChild->height;
	rightHeight = rightChild == NULL? 0 : rightChild->height;

	if(leftHeight > rightHeight)
		return leftHeight+1;
	else
		return rightHeight+1;
}

这里有计算左右子树高度差的函数，左子树高度-右子树的高度。

还有计算该节点在树中的高度，在左右子树的更高者的基础上加1。

然后定义二叉平衡树：

#include"Node.h"

class Tree
{
public:
	Tree();
	void insert(int data);
	bool delete_node(int data);
	int size();
	void display();
private:
	void right_rotate(Node* target);
	void left_rotate(Node* target);
	void pre_order(Node* cur);
	Node* root;
	int count;
};

Tree::Tree()
{
	root = NULL;
	count = 0;
}

void Tree::insert(int data)
{
	if(root == NULL)
		root = new Node(data);
	else
	{
		Node* current = root;
		Node* pre = NULL;
		while(current != NULL)
		{
			pre = current;
			if(data <= current->data)
				current = current->leftChild;
			else
				current = current->rightChild;
		}
		Node* newNode = new Node(data);
		if(data <= pre->data)
			pre->leftChild = newNode;
		else
			pre->rightChild = newNode;  
		newNode->father = pre;
		Node* fatherNode = pre;
		current = newNode;
		while(pre != NULL)
		{
			pre->height = pre->calculateheight();
			pre->distance = pre->calculateDistance();
			if(pre->distance == 2)
			{
				if(pre->leftChild->distance == 1)
				{
					right_rotate(pre);
					pre = pre->father;
				}
				if(pre->leftChild->distance == -1)
				{
					left_rotate(pre->leftChild);
					right_rotate(pre);
					pre = pre->father;
				}
			//	pre = pre->father;
			}
			if(pre->distance == -2)
			{
				if(pre->rightChild->distance == -1)
				{
					left_rotate(pre);
					pre = pre->father;
				}
				if(pre->rightChild->distance == 1)
				{
					right_rotate(pre->rightChild);
					left_rotate(pre);
					pre = pre->father;
				}
				
			}
			current = pre;
			pre = pre->father;
		}
		
	}

	count++;
}

void Tree::left_rotate(Node* target)
{
	Node* tempUp = target->rightChild;
	Node* tempLeft2Right = tempUp->leftChild;

	Node* top = target->father;
	Node* up = new Node(tempUp);
	if(tempUp->leftChild != NULL)
		tempUp->leftChild->father = up;
	if(tempUp->rightChild != NULL)
		tempUp->rightChild->father = up;

	Node* left2right;
	if(tempLeft2Right != NULL)
	{
		left2right = new Node(tempLeft2Right);
		if(tempLeft2Right->leftChild != NULL)
			tempLeft2Right->leftChild->father = left2right;
		if(tempLeft2Right->rightChild != NULL)
			tempLeft2Right->rightChild->father = left2right;
	}
	else
		left2right = NULL;

	if(top != NULL)
	{
		if(top->leftChild == target)
			top->leftChild = up;
		else
			top->rightChild = up;
	}
	up->father = top;
	up->leftChild = target;
	target->father = up;
	target->rightChild = left2right;
	if(left2right != NULL)
		left2right->father = target;

	target->height = target->calculateheight();
	target->distance = target->calculateDistance();
	up->height = up->calculateheight();
	up->distance = up->calculateDistance();
	top->height = top->calculateheight();
	top->distance = top->calculateDistance();

	delete(tempUp);
	delete(tempLeft2Right);

//	target = target->father;

}

void Tree::right_rotate(Node* target)
{
	Node* tempUp = target->leftChild;
	Node* tempRight2Left = tempUp->rightChild;

	Node* top = target->father;
	Node* up = new Node(tempUp);

	if(tempUp->leftChild != NULL)
		tempUp->leftChild->father = up;
	if(tempUp->rightChild != NULL)
		tempUp->rightChild->father = up;
	Node* right2left;

	if(tempRight2Left != NULL)
	{
		right2left = new Node(tempRight2Left);
		if(tempRight2Left->leftChild != NULL)
			tempRight2Left->leftChild->father = right2left;
		if(tempRight2Left->rightChild != NULL)
			tempRight2Left->rightChild->father = right2left;
	}
	else
		right2left = NULL;

	if(top != NULL)
	{
		if(top->leftChild == target)
			top->leftChild = up;
		else
			top->rightChild = up;
	}
	up->father = top;
	up->rightChild = target;
	target->father = up;
	target->leftChild = right2left;
	if(right2left != NULL)
		right2left->father = target;

	target->height = target->calculateheight();
	target->distance = target->calculateDistance();
	up->height = up->calculateheight();
	up->distance = up->calculateDistance();
	top->height = top->calculateheight();
	top->distance = top->calculateDistance();

	delete(tempUp);
	delete(tempRight2Left);

}

int Tree::size()
{
	return count;
}

void Tree::display()
{
	pre_order(root);
}

void Tree::pre_order(Node* cur)
{
	if(cur != NULL)
	{
		pre_order(cur->leftChild);
		printf("%d\n", cur->data);
		pre_order(cur->rightChild);
	}
}

二叉平衡树的关键是，它能够在插入所有元素之后保持平衡，左右子树的高度差不会超过1。所以在每次插入完元素后，检查二叉平衡树是否平衡。只要从插入点开始检查，一直往树的根端检查即可。（其实只需检查一个点）然后确定需要哪种旋转，是单旋转还是双旋转。这里，我用了新的指针来代表旋转所得的新位置。注意指针的指向的改变。