BST二叉排序树与AVL平衡二叉树

什么是二叉排序树呢？上图就是一棵标准的二叉排序树，比如序列：43,2,98,0,4,5；

以前序遍历为例：先入43，再入2，（2比43小，则放在43的左边），再入98，（98比43大，则放在43右边），再入0，（0比43小放在2那边，0比2小，放在2左边），再入4，（4比43小，放在2 那边，4比2大，放在2右边），再入5，（5比43小，5比2大，5比4大，放在4的右边）

总结：大的数据放在当前根结点的右边，小的数据放在左边

BST_insert也是按照这个规则来插入，即插入的数据小，就放在左边，数据大就放在右边

BST_delete通过递归查找需要删除的值，所以需要二级指针TreeNode** T； 删除操作会有三种情况

1.删除的结点是没有孩子，即为树叶

2.删除的结点有一个孩子，即为左孩子或者右孩子

3.删除的结点有两个孩子，即为左孩子和右孩子

第一种情况可以合并在第二种之中：

即如果当前删除的结点左孩子为NULL，用temp记录当前的要删除的结点，再让当前结点指向当前结点的右孩子（就算没有右孩子，那就指向的是NULL），然后再delete刚刚的temp，就完成删除了；如果当前删除的结点右孩子为NULL，则连接器左孩子就行了，后面的操作也是一样

第三种情况有两个解决方法：

1.找当前要删除的结点的左子树的最大结点（左子树的最右边的那个结点），将左子树的最大结点的值赋给当前要删除的结点，然后再删除左子树的最大结点（本质上没有删除我们要删的那个结点，只是换了值）；

2.或者找当前要删除的结点的右子树的最小结点（右子树的最左边的那个结点），也是赋值给要删除的结点

#include<iostream>
using namespace std;
typedef struct TreeNode
{
	int data;
	struct TreeNode* Lchild;
	struct TreeNode* Rchild;
}TreeNode;
TreeNode* BST_search(TreeNode* T, int key)
{
	if (T)//因为要递归，所以先判断该结点是否可以进行递归
	{
		if (key == T->data)
			return T;
		else if (key < T->data)
			return BST_search(T->Lchild, key);
		else
			return BST_search(T->Rchild, key);
	}
	else
		return NULL;
}
void BST_insert(TreeNode** T, int value)
{
	if (*T == NULL)
	{
		*T = new TreeNode;
		(*T)->Lchild = NULL;
		(*T)->Rchild = NULL;
		(*T)->data = value;
	}
	else if (value == (*T)->data)
		return;
	else if (value > (*T)->data)
		return BST_insert(&(*T)->Rchild, value);
	else
		return BST_insert(&(*T)->Lchild, value);
}
void Delete(TreeNode** T)
{
	TreeNode* q;
	TreeNode* s;
	if ((*T)->Lchild == NULL)
	{
		q = *T;
		*T = (*T)->Rchild;
		delete q;
	}
	else if ((*T)->Rchild == NULL)
	{
		q = *T;
		*T = (*T)->Lchild;
		delete q;
	}
	else
	{
		q = *T;
		s = (*T)->Lchild;//往左转，寻找左子树的最大节点（最右边）
		while (s->Rchild)
		{
			q = s;//左转的同时根节点也随之改变
			s = s->Rchild;
		}
		(*T)->data = s->data;
		if (q != *T)
			q->Rchild = s->Lchild;//因为s是最右边，所以如果s还有孩子的话就一定是左孩子,有就补，没有就为NULL
		else
			q->Lchild = s->Lchild;//重接左子树
		delete s;
	}
	return;
}
void BST_delete(TreeNode**T, int key)
{
	if (!*T)
	{
		return;
	}
	else
	{
		if ((*T)->data == key)
			return Delete(T);
		else if ((*T)->data > key)
			return BST_delete(&(*T)->Lchild, key);
		else
			return BST_delete(&(*T)->Rchild, key);
	}
}
void visit(TreeNode* T)
{
	if (T)
		cout << T->data << " ";
	else
		cout << "NULL";
}
void preOrder(TreeNode* T)
{
	if (T)
	{
		visit(T);
		preOrder(T->Lchild);
		preOrder(T->Rchild);
	}
	else
		return;
}
int main()
{
	TreeNode* T = NULL;
	int array[] = { 5, 2, 7, 3, 4, 8, 6 };
	int len = sizeof(array) / sizeof(int);
	for (int i = 0; i < len; i++)
	{
		BST_insert(&T, array[i]);
	}
	preOrder(T);
	cout << endl;
	int key;
	cin >> key;
	TreeNode* node = BST_search(T, key);
	BST_delete(&T, key);
	preOrder(T);
	cout << endl;
}

AVL平衡二叉树

平衡二叉树建立在排序二叉树的基础之上；依然是左边小，右边大；但多加了一个条件，左右子树的高度差不能超过2

因此在AVL_insert中多了一个判断当前左右子树的高度差的操作

#include<iostream>
using namespace std;
typedef struct TreeNode
{
	int data;
	int height;
	struct TreeNode* Lchild;
	struct TreeNode* Rchild;
}TreeNode;
int getHeight(TreeNode* T)
{
	return T ? T->height : 0;
}
int getMax(int a,int b)
{
	return a > b ? a : b;
}
void RR(TreeNode* node, TreeNode** root)//node为当前根节点,root为根节点的地址
{
	TreeNode* temp = node->Rchild;//比如1，2，3；node为根节点，temp为根节点的右孩子
	node->Rchild = temp->Lchild;//右孩子的左孩子（那个圈）赋给根节点的右孩子
	temp->Lchild = node;//根节点成为中间节点的左孩子
	node->height = max(getHeight(node->Lchild), getHeight(node->Rchild)) + 1;
	temp->height = max(getHeight(temp->Lchild), getHeight(temp->Rchild)) + 1;
	*root = temp;
}
void LL(TreeNode* node, TreeNode** root)
{
	TreeNode* temp = node->Lchild;
	node->Lchild = temp->Rchild;
	temp->Rchild = node;
	node->height = max(getHeight(node->Lchild), getHeight(node->Rchild)) + 1;
	temp->height = max(getHeight(temp->Lchild), getHeight(temp->Rchild)) + 1;
	*root = temp;
}
void AVL_insert(TreeNode** T, int key)
{
	if (*T == NULL)
	{
		*T = new TreeNode;
		(*T)->data = key;
		(*T)->height = 0;
		(*T)->Lchild = NULL;
		(*T)->Rchild = NULL;
	}
	else if (key < (*T)->data)
	{
		AVL_insert(&(*T)->Lchild, key);
		//获得当前节点的左右子树的高度
		int Lheight = getHeight((*T)->Lchild);
		int Rheight = getHeight((*T)->Rchild);
		//判断高度差
		if (Lheight - Rheight == 2)
		{
			if (key < (*T)->Lchild->data)
			{
				//LL
				LL(*T, T);
			}
			else
			{
				//LR
				RR((*T)->Lchild, &(*T)->Lchild);
				LL(*T, T);
			}
		}
	}
	else if (key > (*T)->data)
	{
		AVL_insert(&(*T)->Rchild, key);
		int Lheight = getHeight((*T)->Lchild);
		int Rheight = getHeight((*T)->Rchild);
		//判断高度差
		if (Rheight - Lheight == 2)
		{
			if (key > (*T)->Rchild->data)
			{
				//RR
				RR(*T, T);
			}
			else
			{
				//RL
				LL((*T)->Rchild, &(*T)->Rchild);
				RR(*T, T);
			}
		}
	}
	(*T)->height = max(getHeight((*T)->Lchild), getHeight((*T)->Rchild)) + 1;
}
void visit(TreeNode* T)
{
	cout << T->data << " ";
}
void preOrder(TreeNode* T)
{
	if (T)
	{
		visit(T);
		preOrder(T->Lchild);
		preOrder(T->Rchild);
	}
	return;
}


int main()
{
	TreeNode* T = NULL;
	int arry[] = { 1,2,3,4,5 };//21435
	int len = sizeof(arry) / sizeof(int);
	for (int i = 0; i < len; i++)
	{
		AVL_insert(&T, arry[i]);
	}
	preOrder(T);
	cout << endl;
}