AVL_lzw

#include<iostream>
#include<stdlib.h>
using namespace std;


//1.AVL树数据结构 
struct BinaryTreeNode { 
    int key;
    int height;  //记录以该节点位root的树高度
    BinaryTreeNode* left;  //left child
    BinaryTreeNode* right;  //right child 
};

//define AVL node
typedef BinaryTreeNode avlnode;

//define AVL tree
typedef avlnode* avltree;

//比较左右子树高度，取最大的
int maxh( int ha, int hb ) {
    return ha > hb ? ha : hb;
}

//计算树的高度
int height( avltree tree ) {
    if( NULL == tree ) {
        return 0;
    }
    return tree->height;
}


//2.AVL树旋转操作 
//single right rotate for LL model
avlnode* singleRightRotate( avlnode* aNode ) {
    cout<<"//log on singleRightRotate and now the node's value is "<<aNode->key<<endl;
    avlnode* bNode = aNode->left;
    //rebuild relation
    aNode->left = bNode->right;
    bNode->right = aNode;
    //adjust the height
    aNode->height = maxh( height( aNode->right ), height( aNode->left ) ) + 1;
    bNode->height = maxh( height( bNode->right ), height( bNode->left ) ) + 1;
    return bNode;
}

//sigle left rotate for RR model
avlnode* singleLeftRotate( avlnode* aNode ) {
    cout<<"//log on singleLeftRotate and now the node's value is "<<aNode->key<<endl;
    avlnode* bNode = aNode->right;
    //rebuild relation
    aNode->right = bNode->left;
    bNode->left = aNode;
    //adjust the height
    aNode->height = maxh( height( aNode->right ), height( aNode->left ) ) + 1;
    bNode->height = maxh( height( bNode->right ), height( bNode->left ) ) + 1;
    return bNode;
}

//double rotate for LR model
//left rotate first and then right rotate
avlnode* leftRightRotate( avlnode* aNode ) {
    cout<<"||log on leftRightRotate and now the node's value is "<<aNode->key<<endl;
    aNode->left = singleLeftRotate( aNode->left );
    return singleRightRotate(aNode);
}

//double rotate for RL model
//right rotate first and then left rotate
avlnode* rightLeftRotate( avlnode* aNode ) {
    cout<<"||log on rightLeftRotate and now the node's value is "<<aNode->key<<endl;
    aNode->right = singleRightRotate( aNode->right );
    return singleLeftRotate(aNode);
}


//3.插入节点
//insert a key to AVL tree.
avltree avl_insert( avltree &tree, int key ) {
    if( NULL == tree ) {
        tree = (avlnode*)malloc( sizeof( avlnode ) );
        tree->key = key;
        tree->height = 1;
        tree->left = tree->right = NULL;
    }else if( key > tree->key ) {  //insert into the right subtree
        tree->right = avl_insert( tree->right, key );
        int balanceFactor = height( tree->right ) - height( tree->left );
        if( balanceFactor == 2 ) {
            if( key > tree->right->key ) {  //RR model,右侧使用左单旋
                cout<<endl<<"**RR model**,the node's to be single_left_rotated value is "<<tree->key<<" and its height is "<<tree->height<<endl;
                tree = singleLeftRotate(tree);                  
            }
            else{  //RL model,右侧使用RL双旋
                cout<<endl<<"**RL model**,the node's to be right_left_rotated value is "<<tree->key<<" and its height is "<<tree->height<<endl; 
                tree = rightLeftRotate(tree); 
            }
        }       
    }else if( key < tree->key ) {  //insert into the left subtree
        tree->left = avl_insert( tree->left, key );
        int balanceFactor = height( tree->left ) - height( tree->right );
        if( balanceFactor == 2 ) {
            if( key < tree->left->key ) {  //LL model,左侧使用右单旋
                cout<<endl<<"**LL model**,the node's to be single_right_rotated value is "<<tree->key<<" and its height is "<<tree->height<<endl;
                tree = singleRightRotate(tree);                 
            }
            else{  //LR model,左侧使用LR双旋 
                cout<<endl<<"**LR model**,the node's to be left_right_roated value is "<<tree->key<<" and its height is "<<tree->height<<endl;
                tree = leftRightRotate(tree); 
            }
        }       
    }else{  //if the key is already exists, nothing to do...        
    }

    //重新计算树的高度
    tree->height = maxh( height( tree->left ), height( tree->right ) ) + 1;
    cout<<endl<<"now the node's value is "<<tree->key<<" and its height is "<<tree->height<<endl;
    return tree;    
}


//4.删除节点
//delete the given key from AVL tree.
avlnode* avl_delete( avlnode* & tree, int key ) {
    if( NULL == tree ) {
        return NULL;
    }

    //delete the node with the given key
    if( key > tree->key )  {  //key exists in the right subtree
        tree->right = avl_delete( tree->right, key );
    }else if( key < tree->key )  {  //key exists in the left subtree
        tree->left = avl_delete( tree->left, key );
    }else{  //key = tree->key 
        if( NULL != tree->left ) {  //when left is not NULL
            //find max node in left tree
            avlnode* dn = NULL;
            for( dn = tree->left; NULL != dn->right; dn = dn->right ) {             
                //左子树里的最大值在左子树的最右下角 
            }
            //change the value,把tree的左子树里的最大值赋给tree节点，这样通过覆盖的方式就删除了值为key的tree节点 
            tree->key = dn->key;
            //delete the max node,由于这个max node用来替换tree的位置,所以它自己得死亡,这样树的节点总数才会少1 
            cout<<"the next node's to be deleted value is "<<dn->key<<" and its height is "<<dn->height<<endl;
            tree->left = avl_delete( tree->left, dn->key );
            //在tree->left(左子树)里递归得删除值为dn->key的节点。
            //递归的边界就是,某个叶子节点替代了它上一层里需要被删除的节点位置，然后这个叶子节点由于没有替死鬼,就只能被宰割(在最近的下面的else里被杀死) 
        }else if( NULL != tree->right ) {  //when right is not NULL
            //find minimal node in right tree
            avlnode* dn = NULL;
            for( dn = tree->right; NULL != dn->left; dn = dn->left ) {              
                //右子树里的最大值在右子树的最左下角 
            }
            //change the value,把tree的右子树里的最小值赋给tree节点，这样通过覆盖的方式就删除了值为key的tree节点 
            tree->key = dn->key;
            //delete the minimal node,由于这个minimal node用来替换tree的位置,所以它自己得死亡,这样树的节点总数才会少1 
            cout<<"the next node's to be deleted value is "<<dn->key<<" and its height is "<<dn->height<<endl;
            tree->right = avl_delete( tree->right, dn->key );
            //在tree->right(右子树)里递归得删除值为dn->key的节点。
            //递归的边界就是,某个叶子节点替代了它上一层里需要被删除的节点位置，然后这个叶子节点由于没有替死鬼,就只能被宰割(在最近的下面的else里被杀死) 
        }else{  //when the node has no child(替死鬼)
            cout<<"the node's value before delete: "<<tree->key<<endl;
            free(tree);
            //the tree is empty now, no need to do any operation(子树已经递归解决完毕)
            cout<<"the node's value after  delete: "<<tree->key<<endl;
            return NULL;
        }       
    }

    //adjust the tree to balance state after deletion
    if( height( tree->left ) - height( tree->right ) == 2 ) {  //when the left subtree is too high
        if( height( tree->left->right ) - height( tree->right->right ) == 1 ) {  //LR model
            tree = leftRightRotate(tree);
        }
        else { //LL model
            tree = singleRightRotate(tree);
        }
    }else if( height( tree->right ) - height( tree->left ) == 2 ) {  //when the right subtree is too high
        if( height( tree->right->left ) - height( tree->left->left ) == 1 ) {  //RL model
            tree = rightLeftRotate(tree);
        }
        else { //RR model
            tree = singleLeftRotate(tree);
        }
    }else {
        //the tree is already balanced,nothing to do...
    }


    //recalculate the height of the tree.
    tree->height = maxh( height( tree->right ),height( tree->left ) ) + 1;


    return tree;

}


//5.按中序输出AVL树中节点值
void print(avltree &tree, bool out_prompt) {    
    if( true == out_prompt)  {  //输出提醒
        cout<<endl<<endl<<"All value in avl_tree's node by InOrderTraversal is:"<<endl; 
        out_prompt = false;
    }
    if( NULL == tree ) {
        return;
    }
    else {
        print(tree->left,false);
        cout<<tree->key<<" ";
        print(tree->right,false);
    }

}

void more_new_line() {
    cout<<endl<<endl<<endl;
}


int main() {

    avltree test = NULL;
    test = avl_insert( test,10 );
    test = avl_insert( test,1 );
    test = avl_insert( test,100 );
    test = avl_insert( test,3 );
    test = avl_insert( test,2 );

    more_new_line();
    print(test,true);
    more_new_line();

    cout<<endl<<endl<<"Delete 10"<<endl;        
    test = avl_delete( test, 10 );

    more_new_line();
    print(test,true);   
    more_new_line();

    return 0;
}