AVL树的实现

平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：

它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

下面是我的实现，这个算法还是纠结了蛮久的

// AVL-Tree.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <crtdbg.h>
#include<vector>

#define MIN 1000000
struct TreeNode{
int ele;
TreeNode*lnode, *rnode, *parent;
};

TreeNode*minmax = NULL;
int minvalue = MIN;
void find_postion(TreeNode*node, int value)
{
if (node == NULL)
return;
if (node->ele - value > 0 && node->ele - value < minvalue)
{
minmax = node;
minvalue = node->ele - value;
}
find_postion(node->lnode, value);
find_postion(node->rnode, value);
}
int depth_between(TreeNode*floor, TreeNode*ceiling)
{
_ASSERTE(floor != NULL);
int dep = 1;
while (ceiling != floor)
{
floor = floor->parent;
dep++;
}
return dep;
}

int maxdep = 0;
int mindep = MIN;
void depth(TreeNode*ceiling, TreeNode*node)
{
if (node == NULL)
return;
int dep = depth_between(node, ceiling);
if (node->lnode == NULL&&node->rnode == NULL&&dep < mindep)
{
mindep = dep;
}
if (dep > maxdep)
{
maxdep = dep;
}
depth(ceiling, node->lnode);
depth(ceiling, node->rnode);
}

int tree_depth(TreeNode*node)
{
maxdep = 0;
mindep = MIN;
depth(node, node);
return maxdep;
}

int is_balence(TreeNode*node)
{
return tree_depth(node->lnode) - tree_depth(node->rnode);
}

std::vector<TreeNode*>vec;

void inorder(TreeNode*node)
{
if (node == NULL)
return;
inorder(node->lnode);
vec.push_back(node);
inorder(node->rnode);
}

void adjust(TreeNode*root, TreeNode*node)//插入删除后做调整
{
while (node != NULL)
{
int aa = tree_depth(node->lnode);
int bb = tree_depth(node->rnode);
int tt = is_balence(node);
if (tt > 1)
{
if (node->rnode == NULL)
{
if (node->lnode->rnode != NULL)
{
int temp = node->ele;
node->ele = node->lnode->rnode->ele;
node->lnode->rnode->ele = temp;
node->rnode = node->lnode->rnode;
node->lnode->rnode = NULL;
node->rnode->parent = node;
node = node->parent;
}
else
{
int temp = node->ele;
node->ele = node->lnode->ele;
node->lnode->ele = node->lnode->lnode->ele;
node->rnode = node->lnode->lnode;
node->rnode->parent = node;
node->lnode->lnode = NULL;
node->rnode->ele = temp;
node = node->parent;
}
}
else
{

TreeNode*t3 = node->lnode;
_ASSERTE(t3 != NULL);

while (t3->rnode != NULL)
{
t3 = t3->rnode;
}

TreeNode*t4;
t4 = node->rnode;
while (t4->rnode != NULL)
{
t4 = t4->rnode;
}

if (t4->parent->lnode == NULL)//旋转一次，便于后续插入
{
int temp = t4->parent->ele;
t4->parent->ele = t4->ele;
t4->ele = temp;
t4->parent->lnode = t4;
t4->parent->rnode = NULL;
}
TreeNode*t5 = t3->parent;
if (t3->lnode != NULL)
{
t3->lnode->parent = t3->parent;
}
t3->parent->rnode = t3->lnode;
t3->lnode = NULL;

vec.clear();
inorder(node->rnode);
int temp = node->ele;
node->ele = t3->ele;
int t = vec[0]->ele;
vec[0]->ele = temp;
temp = vec.back()->ele;
if (vec.size() == 1)
temp = t;
for (int i = 1; i < vec.size(); i++)
{
vec[i]->ele = vec[i - 1]->ele;
}
vec.back()->rnode = t3;
//t3->lnode = t3->rnode = NULL;
t3->ele = temp;
t3->parent = vec.back();

node = t5;
}
}//end of tt>1

else if (tt < -1)
{
if (node->lnode==NULL)
{
if (node->rnode->rnode != NULL)
{
int temp = node->ele;
node->ele = node->rnode->ele;
node->rnode->ele = node->rnode->rnode->ele;
node->lnode = node->rnode->rnode;
node->rnode->rnode = NULL;
node->lnode->ele = temp;
node->lnode->parent = node;
node = node->parent;
}
else
{
node->lnode = node->rnode->lnode;
node->lnode->parent = node;
node->rnode->lnode = NULL;
int temp=node->lnode->ele;
node->lnode->ele = node->ele;
node->ele = temp;
node = node->parent;
}
}
else//node->lnode !=NULL
{
TreeNode*t1 = node->lnode;
while (t1->rnode != NULL)
{
t1 = t1->rnode;
}
if (t1->parent->lnode == NULL)//旋转，便于后续插入
{
_ASSERTE(t1->lnode == NULL&&t1->rnode == NULL);
int temp = t1->ele;
t1->ele = t1->parent->ele;
t1->parent->ele = temp;
t1->parent->lnode = t1;
t1->parent->rnode = NULL;
}
TreeNode*t2 = node->rnode->lnode;
_ASSERTE(t2 != NULL);
while (t2->lnode != NULL)
{
t2 = t2->lnode;
}
TreeNode*t3 = t2->parent;
t2->parent->lnode = t2->rnode;
if (t2->rnode!=NULL)
t2->rnode->parent = t2->parent;
t1->rnode = t2;
t2->rnode = NULL;
t2->parent = t1;
int temp = node->ele;
node->ele = t2->ele;
t2->ele = temp;

node = t3;
}
}//end of tt<-1

else //-2<tt<2,无需调整
node = node->parent;
}

}

TreeNode* insert(TreeNode*root, int value)//插入
{
if (root == NULL)//当前树为空
{
root = new TreeNode;
root->ele = value;
root->lnode = root->rnode = root->parent = NULL;
return root;
}

minmax = NULL;
minvalue = MIN;
find_postion(root, value);
if (minmax == NULL)//要插入的值比树中所有节点的都大
{
if (root->rnode == NULL)
{
TreeNode*node = new TreeNode;
node->ele = value;
node->parent = root;
root->rnode = node;
node->lnode = node->rnode = NULL;
TreeNode*floor = NULL;
maxdep = -1;
depth(root, root);
_ASSERTE(maxdep == 2);
return root;
}

TreeNode*r_node = root;
while (r_node->rnode != NULL)
{
r_node = r_node->rnode;
}
TreeNode*node = new TreeNode;
node->ele = value;
node->parent = r_node;
r_node->rnode = node;
node->lnode = node->rnode = NULL;
adjust(root, r_node->parent);
return root;
}

TreeNode*nn = minmax->lnode;
if (nn == NULL)
{
TreeNode*node = new TreeNode;
node->ele = value;
node->lnode = node->rnode = NULL;
minmax->lnode = node;
node->parent = minmax;
adjust(root, minmax->parent);//对树做调整
return root;
}
while (nn->rnode != NULL)
{
nn = nn->rnode;
}
TreeNode*node = new TreeNode;
node->ele = value;
node->parent = nn;
nn->rnode = node;
node->lnode = node->rnode = NULL;
adjust(root,nn->parent);//对树做调整
return root;
}
TreeNode*bbb=NULL;
void find(TreeNode*node,const int value)//查找
{
if (node != NULL)
{
if (node->ele == value)
bbb=node;
if (node->ele > value)
find(node->lnode, value);
else
find(node->rnode, value);
}
}

TreeNode*erase(TreeNode*root,const int value)//删除
{
bbb = NULL;
find(root, value);
TreeNode*tobedel = bbb;
if (tobedel != NULL)
{
if (tobedel == root)
{
if (root->lnode == NULL)
{
TreeNode*nn = root->rnode;
nn->parent = NULL;
delete root;
return nn;
}
TreeNode*t1 = root->lnode;
while (t1->rnode != NULL)
{
t1 = t1->rnode;
}
TreeNode*aa = t1->parent;
t1->parent->rnode = t1->lnode;
if (t1->lnode != NULL)
t1->lnode->parent = t1->parent;

t1->lnode = root->lnode;
root->lnode->parent = t1;
t1->parent = NULL;
t1->rnode = root->rnode;
if (root->rnode != NULL)
root->rnode->parent = t1;
if (aa == root)
aa=t1;
delete root;
adjust(t1, aa);
return t1;
}

if (tobedel->lnode == NULL)
{
tobedel->parent->lnode = tobedel->rnode;
if (tobedel->rnode != NULL)
tobedel->rnode->parent = tobedel->parent;
TreeNode*aa = tobedel->parent;
delete tobedel;
adjust(root, aa);
return root;
}
TreeNode*t1 = tobedel->lnode;
while (t1->rnode != NULL)
{
t1 = t1->rnode;
}

t1->parent->rnode = t1->lnode;
if (t1->lnode != NULL)
t1->lnode->parent = t1->parent;
t1->lnode = NULL;
TreeNode*aa = t1->parent;
if (tobedel->parent->lnode == tobedel)
{
tobedel->parent->lnode = t1;
t1->parent = tobedel->parent;
tobedel->parent->rnode = tobedel->rnode;
if (tobedel->rnode != NULL)
tobedel->rnode->parent = tobedel->parent;
delete tobedel;
adjust(root, aa);
return root;
}
else
{
tobedel->parent->rnode = t1;
t1->parent = tobedel->parent;
tobedel->parent->rnode = tobedel->rnode;
if (tobedel->rnode != NULL)
tobedel->rnode->parent = tobedel->parent;
delete tobedel;
adjust(root, aa);
return root;
}
}

return root;
}

int _tmain(int argc, _TCHAR* argv[])
{
TreeNode*root = NULL;
root=insert(root, 100);
root=insert(root, 200);
root=insert(root, 300);
root=insert(root, 50);
root = insert(root, 20);
root = insert(root, 500);
root = insert(root, 700);
root = insert(root, 1100);
root = insert(root, 1500);
root = insert(root, 900);
root = insert(root, 1000);
root = insert(root, 150);
root = insert(root, 350);
root = insert(root, 250);
root = insert(root, 15);
root = insert(root, 10);
root = insert(root, 8);
root = insert(root, 5);

bbb = NULL;
find(root, 150);
TreeNode*aa = bbb;

root = erase(root, 300);
root = erase(root, 150);
system("pause");
return 0;
}