AVL树C++实现(end)

http://www.cnblogs.com/QG-whz/p/5167238.html

#include "Queue.h"  
#include <iostream>  
using namespace std;  
#include <vector>  
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;  
}