using namespace std;
typedef struct avlnode
{
int key;
int height;
struct avlnode* left;
struct avlnode* right;
}AVLNode;
typedef struct avltree
{
AVLNode* root;
}AVLTree;
AVLTree* CreateAVLTree() //创建一个Tree
{
AVLTree* tree = new AVLTree;
tree->root = NULL;
return tree;
}
int RootHeight(const AVLNode* root) //当前节点的高度
{
if(root)
{
return root->height;
}
else
{
return 0;
}
}
int Max(const int& a, const int& b)//求Max
{
return a > b ? a : b;
}
/*
100 85
/ \ 右旋 / \
85 120 ------ -> 60 100
/ \ \ / \
60 90 80 90 120
\
80
*/
void SingleRotateWithLeft(AVLNode** root)
{
AVLNode* temp;
temp = (*root)->left;
(*root)->left = temp->right;
temp->right = *root;
(*root)->height = Max(RootHeight((*root)->left), RootHeight((*root)->right))+1;
temp->height = Max(RootHeight(temp->left), RootHeight(temp->right))+1;
*root = temp;
}
/*
80 90
/ \ 左旋 / \
60 90 ---- -> 80 120
/ \ / \ /
85 120 60 85 100
/
100
*/
void SingleRotateWithRight(AVLNode** root)
{
AVLNode* temp;
temp = (*root)->right;
(*root)->right = temp->left;
temp->left = *root;
(*root)->height = Max(RootHeight((*root)->left), RootHeight((*root)->right))+1;
temp->height = Max(RootHeight(temp->left), RootHeight(temp->right))+1;
*root = temp;
}
/*
100 100 90
/ \ 左旋 / \ 右旋 / \
80 120 ------> 90 120 ------> 80 100
/ \ / / \ \
60 90 80 60 85 120
/ / \
85 60 85
*/
void DoubleRotateWithLeft(AVLNode** root)
{
SingleRotateWithRight(&(*root)->left);
SingleRotateWithLeft(root);
}
/*
80 80 85
/ \ 右 旋 / \ 左 旋 / \
60 100 ------> 60 85 -------> 80 100
/ \ \ / / \
85 120 100 60 90 120
\ / \
90 90 120
*/
void DoubleRotateWithRight(AVLNode** root)
{
SingleRotateWithLeft(&(*root)->right);
SingleRotateWithRight(root);
}
AVLNode* FindNode(int data, AVLNode* root) //FindNode
{
if(NULL == root)
{
return NULL;
}
else if(data < root->key)
{
return FindNode(data, root->left);
}
else if(data > root->key)
{
return FindNode(data, root->right);
}
else
{
return root;
}
}
AVLNode* FindNode(int data, AVLNode* root) //非递归
{
while(root)
{
if(data == root->key)
{
return root;
}
else if(data < root->key)
{
root = root->left;
}
else
{
root = root->right;
}
}
return NULL;
}
AVLNode* FindMin(AVLNode* root) //FindMin
{
if(NULL == root)
{
return NULL;
}
else if( NULL== root->left)
{
return root;
}
else return FindMin(root->left);
}
AVLNode* FindMax(AVLNode* root) //FindMax
{
if(NULL == root)
{
return NULL;
}
else if( NULL== root->right)
{
return root;
}
else return FindMax(root->right);
}
bool AVLInsert(AVLNode* &root, int data)//插入
{
if(NULL == root)
{
root = new AVLNode;
if(NULL == root)
{
return false;
}
root->key = data;
root->height = 0;
root->left = NULL;
root->right = NULL;
}
else if(NULL != FindNode(data,root))
{
cout<<data<<" has been insert ! ";
}
else if(data < root->key)
{
AVLInsert(root->left, data);
if(2 == RootHeight(root->left) - RootHeight(root->right))
{
if(data < root->left->key)
{
SingleRotateWithLeft(&root);
}
else
{
DoubleRotateWithLeft(&root);
}
}
}
else if(data > root->key)
{
AVLInsert(root->right, data);
if(2 == RootHeight(root->right) - RootHeight(root->left))
{
if(data > root->right->key)
{
SingleRotateWithRight(&root);
}
else
{
DoubleRotateWithRight(&root);
}
}
}
root->height = Max(RootHeight(root->left), RootHeight(root->right))+1;
return true;
}
bool AVLDelete(AVLNode* &root, int data) // 删除
{
AVLNode* temp;
if(NULL == root)
{
return false;
}
else if(data < root->key)
{
AVLDelete(root->left, data);//左边删除
if(2 == RootHeight(root->right) - RootHeight(root->left))
{
if(RootHeight(root->right->left) < RootHeight(root->right->right))
{
SingleRotateWithRight(&root);//右边太多
}
else
{
DoubleRotateWithRight(&root);//右边太多
}
}
}
else if(data > root->key)
{
AVLDelete(root->right, data);
if(2 == RootHeight(root->left) - RootHeight(root->right))
{
if(RootHeight(root->left->right) > RootHeight(root->left->left))
{
SingleRotateWithLeft(&root);
}
else
{
DoubleRotateWithRight(&root);
}
}
}
else
{
if((root->left != NULL) && (root->right != NULL))
{
//如果左子树比右子树高 则删除左边最大值
if(RootHeight(root->left) > RootHeight(root->right))
{
temp = FindMax(root->left);
root->key = temp->key ;
AVLDelete(root->left, root->key);
}
else //右子树比左子树高 则删除右边最小值
{
temp = FindMin(root->right); //右边找最小值
root->key = temp->key; //将找到的值赋给当前root
AVLDelete(root->right, root->key); //删除在右边找到的值
}
}
else
{
temp = root;
if(NULL == root->left )
{
root = root->right;
}
else if(NULL == root->right)
{
root = root->left;
}
delete temp;
temp = NULL;
}
return true;
}
}
int TotalNodeNum(AVLNode* root) //节点总数
{
if(root)
{
int LNodeNum = TotalNodeNum(root->left);
int RNodeNum = TotalNodeNum(root->right);
return LNodeNum + RNodeNum +1;
}
return 0;
}
int LeafNodeNum(AVLNode* root)//叶子节点数
{
int leaf = 0;
int LNodeNum = 0;
int RNodeNum = 0;
if(root)
{
if(NULL==root->left && NULL == root->right)
{
leaf =1;
}
else
{
LNodeNum = LeafNodeNum(root->left);
RNodeNum = LeafNodeNum(root->right);
leaf = LNodeNum + RNodeNum;
}
}
else
{
return 0;
}
return leaf;
}
void DestroyNode(AVLNode* & root) //清除节点
{
while(root)
{
DestroyNode(root->left);
DestroyNode(root->right);
delete root;
root = NULL;
}
}
void DestroyTree(AVLTree* &tree) //清除树
{
DestroyNode(tree->root);
delete tree;
}
int RootDepth(AVLNode* root)//这个节点的深度
{
if(root)
{
int LHigh = RootDepth(root->left);
int RHigh = RootDepth(root->right);
return LHigh > RHigh ? LHigh+1 : RHigh+1;
}
return 0;
}
void SwapRootLeftRight(AVLNode * root)//实现交换每个节点的左右节点 镜像
{
AVLNode* temp;
if(root)
{
temp = root->left;
root->left = root->right;
root->right = temp;
SwapRootLeftRight(root->left);
SwapRootLeftRight(root->right);
}
}
void PreOrderTraverse(const AVLNode* root)
{
if(root)
{
cout << root->key << " ";
PreOrderTraverse(root->left);
PreOrderTraverse(root->right);
}
}
void InOrderTraverse(const AVLNode* root)
{
if(root)
{
InOrderTraverse(root->left);
cout << root->key << " ";
InOrderTraverse(root->right);
}
}
void PostOrderTraverse(const AVLNode* root)
{
if(root)
{
PostOrderTraverse(root->left);
PostOrderTraverse(root->right);
cout << root->key << " ";
}
}
void LevelTraverse( AVLNode* root)
{
if(NULL == root)
{
return;
}
vector<AVLNode*>vec;
vec.push_back(root);
int cur = 0;
while(cur < vec.size())
{
cout<<vec[cur]->key<<" ";
if(NULL != vec[cur]->left)
{
vec.push_back(vec[cur]->left);
}
if(NULL != vec[cur]->right)
{
vec.push_back(vec[cur]->right);
}
cur++;
}
}
void AllOrderTraverse( AVLNode* root)
{
cout << "PreOrder: ";
PreOrderTraverse(root);
cout << endl;
cout << "InOrder: ";
InOrderTraverse(root);
cout << endl;
cout << "PostOrder: ";
PostOrderTraverse(root);
cout << endl;
cout << "LevelOrder: ";
LevelTraverse(root);
cout << endl;
}
int main()
{
AVLTree* tree = CreateAVLTree();
for(int i = 1; i <= 7; i++)
{
AVLInsert(tree->root, i);
}
for(int i = 16; i >= 10; i--)
{
AVLInsert(tree->root, i);
}
AVLInsert(tree->root, 8);
AVLInsert(tree->root, 9);
AllOrderTraverse(tree->root);
cout<<endl;
int total = TotalNodeNum(tree->root);
int leaf = LeafNodeNum(tree->root);
int node2 = leaf-1;//前提是leaf > 1
int node1 = total - leaf - node2;
return 0;
}
