平衡二叉树(AVLTREE,双链表实现)

首先说下好久没更新了，最近打游戏和工作都有点多，o(^▽^)o。

写这个AVL发现自己的代码风格好差，尤其是变量命名这块，后来意识到了，想去改，但是太多了，改了几个就不想改了，做这个是记录下自己的成长吧。

另外说下，调这个AVL真心有点烦了，前面写了一个，但是逻辑有点乱，基本的删除都测差不多ok了，发现一个bug，实在不想去看那代码，太乱了，后来强b这自己去重新写，花了1个多小时（当然是加班的时候理），理清了，晚上9点多回来，大概3个小时，把del这块从新改完了，写代码真的是一个时候一个思想，发现处理节点只有单个分支的时候，还是第一次的思想好，直接指针操作一下，逻辑很精简，具体可以看code708的那2段逻辑处理，在处理删除节点有2个孩子节点时，在思考用指针直接处理，还是用一个临时变量来操作，最后选择了临时变量节点来处理，具体为什么，因为简单，而且仔细想了想这样处理是没错的，node里data基本只是一个keyValue，用在avl里查找，删除，构造做参考的，这个地方也有考虑用指针，也实现了，基本没多大问题，后来出bug的时候在那理了半天，实在受不了，把他改造了。

另外printAVL的函数直接copy BTree的，这个没什么好说的，还有AVL查找，这个真的不用我写了。本文主要就实现任意的一个数组构造AVLTree，删除AVLTree的任意个节点，保证AVLTree的特性。

具体贴代码，如下，测试的例子，都ok的，具体的放开，还有千万一定要吐槽我的变量命名及注释及很多，我在改，下次写的时候一定注意。

/*运行环境QT C   */

#include <stdio.h>
#define DEBUG 0
//参考图http://www.cnblogs.com/skywang12345/p/3577360.html
#define PRINTTREEINIT(a)
        printf("------------------init Tree begin-------------
");
        PrintBTree(a);
        printf("------------------init Tree end-------------
");
#define PRINTTREEAVL(a)
        printf("------------------AVL Tree begin-------------
");
        PrintBTree(a);
        printf("------------------AVL Tree end-------------
");

#define PRINTTREEDEL(a)
        printf("------------------after del node Tree begin-------------
");
        PrintBTree(a);
        printf("------------------after del nodeTree end-------------
");

#define PRINTTREEADJ(a)
        printf("------------------after adjust  Tree begin-------------
");
        PrintBTree(a);
        printf("------------------after adjust Tree end-------------
");
#define L 1
#define R -1
#define BTREE AVLTree
typedef struct treenode
 {
     int data;
     int hight;
     struct treenode *parent;
     struct treenode *lchild;
     struct treenode *rchild;
} TreeNode;
typedef enum {LL=0,LR,RR,RL,RLR} TURNFLAG;
typedef TreeNode* AVLTree;
typedef int DATATYPE;
int IsLeafNode(TreeNode* Node);
//void DeleteNode(AVLTree* btree, DATATYPE delData);
void DeleteNode(AVLTree* btree, DATATYPE delData);

TreeNode* InitNode(int data);
void InitAVLTree(AVLTree *avlTree, TreeNode *root);

TreeNode *GetFixNode(AVLTree *btree, DATATYPE data);
int GetTreeHight(AVLTree *btree);
TreeNode *InsertNode(TreeNode* parNode, DATATYPE data);
int GetDiffHeight(TreeNode* rootNode);
int AdjustNode(TreeNode* posNode, AVLTree *avlTree);
int GetSymDiffHeight(TreeNode* rootNode);
int IsRoot(TreeNode* rootNode);
int IsLChild(TreeNode* rootNode);
TreeNode *GetMaxNode(TreeNode* rootNode);
TreeNode *GetMinNode(TreeNode* rootNode);
TreeNode* AdjustNodeByTurnFlag(TreeNode** Node,TURNFLAG a, AVLTree *avlTree);
void PrintNTab(int num);
void PrintBTree(BTREE* btree);
void PrintViewTreeNode(TreeNode* treeNode, int num);
TreeNode* GetPosByKeyValue(TreeNode* rootNode,int key);
int GetChildNum(TreeNode* rootNode);
int GetChildNum(TreeNode* curNode)
{
   if((NULL != curNode->lchild)&&(NULL != curNode->rchild))  return 2;
   if((NULL != curNode->lchild)&&(NULL == curNode->rchild))  return 1;
   if((NULL == curNode->lchild)&&(NULL != curNode->rchild))  return -1;
   if((NULL == curNode->lchild)&&(NULL == curNode->rchild))  return 0;

}
TreeNode *GetMaxNode(TreeNode* rootNode)
{
    if(rootNode == NULL) return NULL;
    if(NULL == rootNode->rchild) return rootNode;
    TreeNode *curNode  = rootNode;
    while((NULL != curNode)&&(NULL != curNode->rchild))
    {
        curNode = curNode->rchild;
    }
    return curNode;
}

TreeNode *GetMinNode(TreeNode* rootNode)
{
    if(rootNode == NULL) return NULL;
    if(NULL == rootNode->lchild) return rootNode;
    TreeNode *curNode  = rootNode;
    while((NULL != curNode)&&(NULL != curNode->lchild))
    {
        curNode = curNode->lchild;
    }
    return curNode;
}

TreeNode* GetPosByKeyValue(TreeNode* rootNode,int data)
{
    if(rootNode == NULL) return NULL;
    if(data == rootNode->data) return rootNode;


    TreeNode* curTreeNode = rootNode;

    while( NULL != curTreeNode )
    {
        if(data > curTreeNode->data)
        {
            if(curTreeNode->rchild != NULL)
            {
                //printf("curTreeNode->rchild != NULL rchild[%d]
", curTreeNode->rchild->data);
                curTreeNode = curTreeNode->rchild;
            }else{
                curTreeNode = NULL;
                break;
            }
        }
        else if(data < curTreeNode->data)
        {
            if(curTreeNode->lchild != NULL)
            {
                curTreeNode = curTreeNode->lchild;
            }else{
                curTreeNode = NULL;
                break;
            }
        }
        else
        {
            printf("find key.
", __LINE__);
            return curTreeNode;
        }

    }
    if(NULL == curTreeNode)
    {
        printf("Not find key.
", __LINE__);
        return curTreeNode;
    }

}
void PrintViewTreeNode(TreeNode* treeNode, int num)
{
    if(NULL == treeNode) return ;
    num++;
    printf("%d", treeNode->data);
    if(treeNode->lchild == NULL)
    {
        printf("
");
        PrintNTab(num);
        printf("*");
    }
    else
    {    printf("
");
         PrintNTab(num);
         PrintViewTreeNode(treeNode->lchild, num);
    }
    if(treeNode->rchild == NULL)
    {
        printf("
");
        PrintNTab(num);
        printf("&");

    }
    else
    {
        printf("
");
        PrintNTab(num);
        PrintViewTreeNode(treeNode->rchild, num);

    }


}
void PrintBTree(BTREE* btree)
{
    int num = 0;
    if(btree==NULL)
    {
        printf("empty tree.
");
    }

    printf("***********TREE View BEGIN***********
");
    //PrintTreeNode((*btree));
    PrintViewTreeNode(*btree, num);
    printf("
");
    printf("***********TREE View END ***********
");
    printf("
");

    printf("
");


}
void PrintNTab(int num)
{
    int i = 0;

    while(i<num)
    {
       printf("    ");
       i++;
    }
}
TreeNode* AdjustNodeByTurnFlag(TreeNode** node,TURNFLAG tFlag,AVLTree *avlTree)
{//* >  ->优先级
    TreeNode* nodeTmp = (TreeNode* )malloc(sizeof(TreeNode));
    TreeNode* freeNode = NULL;
    int isRootNode = 0;
    int sdh = 0;
    int iRet = 0;
    memset(nodeTmp, 0x00, sizeof(TreeNode));
    if(((tFlag>3) ||(tFlag <0)|| ((*node)==NULL))) return NULL;
    switch (tFlag){
        case LL:
            freeNode = *node;
            memcpy(nodeTmp,(*node)->lchild,sizeof(TreeNode));
            *node = (*node)->lchild;

            (*node)->parent = nodeTmp->parent;
            iRet = IsLChild(freeNode);
            if(iRet == -1)
            {
                //root
                isRootNode = 1;
            }
            else if(1 == iRet)
            {
                //isLchild
                freeNode->parent->lchild = *node;
            }
            else if(0 == iRet)
            {
                //isRchild
                freeNode->parent->rchild = *node;
            }

            (*node)->rchild = freeNode;
            freeNode->parent = *node;

            freeNode->lchild = nodeTmp->rchild;
            if(NULL != nodeTmp->rchild)
            {
                freeNode->lchild->parent = freeNode;
            }
            if(isRootNode)
            {
                *avlTree = *node;
            }
            free(nodeTmp);
            break;
        case LR:
            freeNode = *node;
            memcpy(nodeTmp,(*node)->lchild->rchild,sizeof(TreeNode));
            *node = (*node)->lchild->rchild;
            (*node)->parent = freeNode->parent;
            iRet = IsLChild(freeNode);
            if(iRet == -1)
            {
                //root
                isRootNode = 1;
            }
            else if(1 == iRet)
            {
                //isLchild
                freeNode->parent->lchild = *node;
            }
            else if(0 == iRet)
            {
                //isRchild
                freeNode->parent->rchild = *node;

            }
            (*node)->lchild = freeNode->lchild;
            freeNode->lchild->parent = *(node);
            freeNode->lchild->rchild = NULL;
            freeNode->lchild = NULL;

            (*node)->rchild = freeNode;
            freeNode->parent = *(node);

            freeNode->lchild = nodeTmp->rchild;
            (*node)->lchild->rchild = nodeTmp->lchild;
            if(NULL != nodeTmp->rchild)
            {
                nodeTmp->rchild->parent = freeNode;
            }
            if(NULL != nodeTmp->lchild)
            {
                nodeTmp->lchild->parent = (*node)->lchild;
            }

            if(isRootNode)
            {
                *avlTree = *node;
            }
            free(nodeTmp);
            break;

        case RR:
            //直接改变指针，所以入参是二级指针
            freeNode = *node;
            memcpy(nodeTmp,*node,sizeof(TreeNode));
            *node=(*node)->rchild;

            if(nodeTmp->parent != NULL)
            {
                if(IsLChild(nodeTmp)){nodeTmp->parent->lchild = *node;}
                else {nodeTmp->parent->rchild = *node;}
            }
            else
            {
             //说明nodeTmp是根节点，要改变树的节点
                isRootNode = 1;
            }

            if((*node)->lchild){
                nodeTmp->rchild = (*node)->lchild;
                (*node)->lchild->parent = nodeTmp;
            }
            (*node)->parent = nodeTmp->parent;
            (*node)->lchild = nodeTmp;
            nodeTmp->parent = *node;
            if(isRootNode)
            {
                *avlTree = *node;
            }
            free(freeNode);
            //树的根节点被改了,这里要注意，刚好玩玩二级指针
             break;
        case RL:
            freeNode = *node;
            memcpy(nodeTmp,(*node)->rchild->lchild,sizeof(TreeNode));
            *node = (*node)->rchild->lchild;
            (*node)->parent = freeNode->parent;
            iRet = IsLChild(freeNode);
            if(iRet == -1)
            {
                //root
                isRootNode = 1;
            }
            else if(1 == iRet)
            {
                //isLchild
                freeNode->parent->lchild = *node;
            }
            else if(0 == iRet)
            {
                //isRchild
                freeNode->parent->rchild = *node;

            }
            (*node)->rchild = freeNode->rchild;
            freeNode->rchild->parent = *(node);
            freeNode->rchild->lchild = NULL;
            freeNode->rchild = NULL;

            (*node)->lchild = freeNode;
            freeNode->parent = *(node);

            freeNode->rchild = nodeTmp->lchild;
            (*node)->rchild->lchild = nodeTmp->rchild;
            if(NULL != nodeTmp->lchild)
            {
                nodeTmp->lchild->parent = freeNode;
            }
            if(NULL != nodeTmp->rchild)
            {
                nodeTmp->rchild->parent = (*node)->rchild;
            }

            if(isRootNode)
            {
                *avlTree = *node;
            }
            free(nodeTmp);
            break;
        default:
             break;
        }
    return *node;

}

//1->is
int IsLChild(TreeNode* sonNode)
{
    if(sonNode->parent ==NULL)return -1;
    return ((sonNode->parent->lchild == sonNode)?1:0);
}


//1->is
int IsRoot(TreeNode* rootNode)
{
    return(rootNode->parent == NULL);
}
int GetDiffHeight(TreeNode* rootNode)
{

    int lh=GetTreeHight((AVLTree*)&(rootNode->lchild));//L
    int rh=GetTreeHight((AVLTree*)&(rootNode->rchild));//R
    return ((lh>rh)?(lh-rh):(rh-lh));
}

int GetSymDiffHeight(TreeNode* rootNode)
{
    int lh=GetTreeHight((AVLTree*)&(rootNode->lchild));//L
    int rh=GetTreeHight((AVLTree*)&(rootNode->rchild));//L
    return  (lh-rh);
}

int AdjustNode(TreeNode* posNode, AVLTree* avlTree)
{//这个函数写的有点问题，如果传入的posNode　 dh = 2时候，而起父节点平衡了，就会少调整一部分，所以入posNode尽量用son
    int dh = GetDiffHeight(posNode);
    int sdh = 0;
    int sSondh = 0;
    if(0== dh)return 0;
    if(2 == dh)
    {
        //这个地方后补上去的，感觉这个AVL树写的到处是漏洞啊汗
        if(NULL != posNode->lchild)
        {
            posNode = posNode->lchild;
        }
        else if(NULL != posNode->rchild)
        {
            posNode = posNode->rchild;
        }
    }

    TreeNode *parNode = posNode->parent;
    if(NULL == parNode ) return 0;
    dh = GetDiffHeight(parNode);
    //l-r =0
    while(parNode&&dh)
    {
        if(2==dh)
        {
            sdh = GetSymDiffHeight(parNode);
            if(-2 == sdh)
            {
                //in RL
                sSondh = GetSymDiffHeight((parNode->rchild));
                if(1==sSondh)
                {
                    //RL
                    AdjustNodeByTurnFlag(&parNode,RL,avlTree);
                    PrintBTree(avlTree);
                }
                else
                {
                    //RR
                   AdjustNodeByTurnFlag(&parNode,RR,avlTree);
                }
            }
            else
            {
                //in L
                sSondh = GetSymDiffHeight(parNode->lchild);
                if(1==sSondh)
                {
                    //LL
                    AdjustNodeByTurnFlag(&parNode,LL,avlTree);
                }
                else
                {
                    //LR
                    AdjustNodeByTurnFlag(&parNode,LR,avlTree);
                }
            }
            break;
        }
        parNode = parNode->parent;
        if(parNode != NULL)
        {
            dh = GetDiffHeight(parNode);

        }
    }

}
TreeNode *InsertNode(TreeNode* parNode, DATATYPE data)
{
    TreeNode* sonTreeNode = InitNode(data);
    if((parNode->lchild != NULL)&&(parNode->rchild == NULL)) parNode->rchild = sonTreeNode;
    if((parNode->rchild != NULL)&&(parNode->lchild == NULL)) parNode->lchild = sonTreeNode;
    if((parNode->rchild == NULL)&&(parNode->lchild == NULL))
    {
        if(data < parNode->data)
        {
             parNode->lchild = sonTreeNode;
        }
        else{
            parNode->rchild = sonTreeNode;

        }
    }
    sonTreeNode->parent = parNode;

    return sonTreeNode;

}

int IsLeafNode(TreeNode* Node)
{
    return ((Node->lchild == NULL)&&(Node->rchild == NULL));
}

int GetTreeHight(AVLTree *btree)
{//这里后来处理，空树的高度是0，根节点的高度1
    TreeNode*curNode = *btree;
    if((curNode ==NULL)) return 0;
    if(IsLeafNode(curNode)) return 1;


    if(((curNode->lchild != NULL)&&(curNode->rchild ==NULL)&&IsLeafNode(curNode->lchild))
            ||((curNode->lchild == NULL)&&(curNode->rchild !=NULL)&&IsLeafNode(curNode->rchild))
            ||((curNode->lchild != NULL)&&(curNode->rchild !=NULL)&&IsLeafNode(curNode->rchild)&&IsLeafNode(curNode->lchild))
            )
    return 2;
    int leftHeight = GetTreeHight((AVLTree*)&((*btree)->lchild));
    int rightHeight = GetTreeHight((AVLTree*)&((*btree)->rchild));
    return ((leftHeight>rightHeight)?leftHeight:rightHeight)+1;

}
TreeNode* InitNode(int data)
{
    TreeNode* newNode  = (TreeNode*)malloc(sizeof(TreeNode));
    memset(newNode, 0x00, sizeof(TreeNode));
    newNode->data = data;
    newNode->hight = 0;
    return newNode;
}
//return rootNode addr
void InitAVLTree(AVLTree *avlTree, TreeNode *root)
{
    *avlTree = root;
}

//查找合适的位置来插入新元素(find parent)
TreeNode* GetFixNode(AVLTree *AVLTree, DATATYPE data)
{
     if((AVLTree == NULL ))
     {
         return NULL;
     }

     if(((*AVLTree)->lchild == NULL)
             &&((*AVLTree)->rchild == NULL))
     {
         //InsertNode(*AVLTree ,data);
#if DEBUG
         printf("insert under root 
");
#endif
         return *AVLTree;
     }
     TreeNode* curTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
     curTreeNode = *AVLTree;
     while( (curTreeNode->lchild != NULL)
           ||(curTreeNode->rchild !=NULL) )
     {
         if(data > curTreeNode->data)
         {
#if DEBUG
             printf(" data=[%d] curData=[%d] insert R 
", data, curTreeNode->data);
#endif
             if(curTreeNode->rchild != NULL)
             {
#if DEBUG
                 printf("curTreeNode->rchild != NULL rchild[%d]
", curTreeNode->rchild->data);
#endif
                 curTreeNode = curTreeNode->rchild;

             }else{

                 break;
             }
         }
         else if(data < curTreeNode->data)
         {
#if DEBUG
             printf(" data=[%d] curData=[%d] insert L 
", data, curTreeNode->data);
#endif
             if(curTreeNode->lchild != NULL)
             {
                 curTreeNode = curTreeNode->lchild;
             }else{

                 break;
             }
         }
         else
         {
             printf("invaild elem here at line %d.
", __LINE__);
             return NULL;
         }

     }
     return curTreeNode;

}

//contruct tree
AVLTree* InitBTree(DATATYPE oriData[],  int size)
{
    int iRet = -1;
    AVLTree* avlTree = NULL;
    avlTree = (AVLTree*)malloc(sizeof(AVLTree));
    //*avlTree = (TreeNode*)malloc(sizeof(TreeNode));
    int pos = size;
    TreeNode* rootNode = InitNode(oriData[0]);
    InitAVLTree(avlTree, rootNode);

    TreeNode *posNode = (TreeNode*)malloc(sizeof(TreeNode));
    while(pos>1)
    {
#if DEBUG
        printf("********begin one*************
");
        printf("pos = [%d] index =[%d] data[%d]
", pos, size-pos+1, oriData[size-pos+1]);
#endif
        posNode = GetFixNode(avlTree, oriData[size-pos+1]);
#if DEBUG
        printf("Parent = [%d] Insert data=[%d]  
", posNode->data, oriData[size-pos+1] );
#endif
        InsertNode(posNode, oriData[size-pos+1]);
        //judge and confit
        //PrintBTree(avlTree);

        iRet = AdjustNode(posNode, avlTree);
        pos--;
#if DEBUG
        printf("********end one*************

");
#endif
        //PrintBTree(avlTree);


    }
    //PrintBTree(avlTree);
    return avlTree;

}


void DeleteNode(AVLTree* avlTree, DATATYPE delKey)
{
    TreeNode* posNode = GetPosByKeyValue(*avlTree,delKey);
    int iIsRootNode = 0;
    int iIsLchlid = 0;

    int iHight = 0; /*处理传入节点in，freeNode 是 in的直接孩子节点情况，这个最早写的时候考虑不周*/

    if(posNode == *avlTree)
    {
        printf("del root node
");
        iIsRootNode = 1;
    }
    /*看到定义的变量没用，感觉好恶心*/
    //TreeNode* parNode = NULL;//这个是临时变量，后面写，发现定义parnode是错的，应该定义tmpNode
    TreeNode* freeNode = NULL;//这个是临时变量，后面写 ，应该定义tmpNode
    //TreeNode* freeNodePar = NULL;//这个是临时变量，后面写 ，应该定义tmpNode
    //TreeNode* curNode  = NULL;//这个是临时变量，后面写 ，应该定义tmpNode

    //TreeNode* pLeftChildOfPosNode = NULL;
    //TreeNode* pRightChildOfPosNode = NULL;
    TreeNode* pParentOfPosNode = NULL;
    //TreeNode* pCurPosNode = NULL;


    //TreeNode* pLeftChildOfFreeNode = NULL;
    //TreeNode* pRightChildOfFreeNode = NULL;
    TreeNode* pParentOfFreeNode = NULL;
    TreeNode  stTmpNode;
    memset(&stTmpNode, 0x00, sizeof(TreeNode));

    int iFlagLR = 0;//judge isLchild
    int iTagIsSon = 0;//judge isLchild

    int sdh = 0;//diff LR height of node
    int iChildNum = 0;
    int iNum = 0;
    if(NULL != posNode )
    {
        iChildNum = GetChildNum(posNode);
        iFlagLR = IsLChild(posNode);

        if(0 == iChildNum)
        {
            if(iIsRootNode)
            {
                free(posNode);
                *avlTree = NULL;
                return;
            }
            else
            {
                //isLeafNode
                pParentOfPosNode = posNode->parent;

                if(1 == iFlagLR)
                {
                    //L
                    pParentOfPosNode->lchild = NULL;

                }else if(0 == iFlagLR)
                {
                    pParentOfPosNode->rchild = NULL;
                }
                free(posNode);
                AdjustNode(pParentOfPosNode, avlTree);

            }

        }
        else if(1 == iChildNum)
        {
            /*这段逻辑是最早写的，后来重理逻辑，理的很复杂，后来的逻辑基本是处理节点方法*/
            pParentOfPosNode = posNode;
            posNode = posNode->lchild;
            if(iIsRootNode)
            {
                *avlTree =  posNode;
            }
            else
            {
                if(1 == iFlagLR)
                {
                    //L
                    pParentOfPosNode->parent->lchild = posNode ;
                }else if(0 == iFlagLR)
                {
                    pParentOfPosNode->parent->rchild = posNode ;
                }
            }
            posNode->parent = pParentOfPosNode->parent;
            free(pParentOfPosNode);
            AdjustNode(posNode, avlTree);
        }
        else if(-1 == iChildNum)
        {
            pParentOfPosNode = posNode;
            posNode = posNode->rchild;
            if(iIsRootNode)
            {
                *avlTree =  posNode;
            }
            else
            {
                if(1 == iFlagLR)
                {
                    //L
                    pParentOfPosNode->parent->lchild = posNode ;
                }
                else if(0 == iFlagLR)
                {
                    pParentOfPosNode->parent->rchild = posNode ;
                }
            }
            posNode->parent = pParentOfPosNode->parent;
            free(pParentOfPosNode);
            AdjustNode(posNode, avlTree);
        }
        else if(2 == iChildNum)
        {

          /*********begin**********/
            sdh = GetSymDiffHeight(posNode);
            if((1 == sdh)
                    ||(0 == sdh))
            {
                //左子树比右子树高,调整左子树
                //pCurPosNode = posNode;
                freeNode = GetMaxNode(posNode->lchild);
                iNum = GetChildNum(freeNode);
                memset(&stTmpNode, 0x00, sizeof(TreeNode));
                memcpy(&stTmpNode, freeNode, sizeof(TreeNode));
                memcpy(freeNode, posNode, sizeof(TreeNode));
                freeNode->data = stTmpNode.data;
                if(iIsRootNode){
                    *avlTree = freeNode;
                }
                else
                {
                    if(iFlagLR)
                    {
                        posNode->parent->lchild = freeNode;
                    }
                    else
                    {
                        posNode->parent->rchild = freeNode;
                    }
                }
                if(0 == iNum)
                {/*process*/

                    pParentOfFreeNode = stTmpNode.parent;
                    if(stTmpNode.parent != posNode)
                    {
                        posNode->lchild->parent = freeNode;
                        posNode->rchild->parent = freeNode;
                        pParentOfFreeNode->rchild = NULL;
                    }
                    else
                    {
                        freeNode->lchild = NULL;
                    }

                    free(posNode);

                    if(stTmpNode.parent != posNode)
                    {
                        AdjustNode(pParentOfFreeNode, avlTree);
                    }
                    else
                    {
                        AdjustNode(freeNode, avlTree);
                    }


                }
                else if(1 == iNum)
                {
                    /*这个属于异常分支，会指向自己*/
                    //process posNode
                    if(stTmpNode.parent != posNode)
                    {
                        posNode->lchild->parent = freeNode;
                        posNode->rchild->parent = freeNode;

                    }
                    else
                    {
                        stTmpNode.lchild->parent = freeNode;
                        posNode->rchild->parent = freeNode;
                    }
                    //process freeNode
                    if(stTmpNode.parent != posNode)
                    {
                        stTmpNode.lchild->parent  = stTmpNode.parent;
                        stTmpNode.parent->rchild = stTmpNode.lchild;
                    }
                    else
                    {
                        stTmpNode.lchild->parent = freeNode;
                        freeNode->lchild = stTmpNode.lchild;
                    }

                    free(posNode);
                    //AdjustNode(stTmpNode.parent, avlTree);
                    if(stTmpNode.parent != posNode)
                    {
                        AdjustNode(stTmpNode.parent, avlTree);
                    }
                    else
                    {
                        AdjustNode(freeNode, avlTree);
                    }

                }
            }
            else if(-1 == sdh)
            {
                //左子树比右子树低,调整右子树
                //pCurPosNode = posNode;
                freeNode = GetMinNode(posNode->rchild);
                iNum = GetChildNum(freeNode);
                memset(&stTmpNode, 0x00, sizeof(TreeNode));
                memcpy(&stTmpNode, freeNode, sizeof(TreeNode));
                memcpy(freeNode, posNode, sizeof(TreeNode));
                freeNode->data = stTmpNode.data;
                if(iIsRootNode){
                    *avlTree = freeNode;
                }
                else
                {
                    if(iFlagLR)
                    {
                        posNode->parent->lchild = freeNode;
                    }
                    else
                    {
                        posNode->parent->rchild = freeNode;
                    }
                }
                if(0 == iNum)
                {/*process*/
                    pParentOfFreeNode = stTmpNode.parent;
                    if(stTmpNode.parent != posNode)
                    {
                        posNode->lchild->parent = freeNode;
                        posNode->rchild->parent = freeNode;
                        pParentOfFreeNode->lchild = NULL;
                    }
                    else
                    {
                        freeNode->rchild = NULL;
                    }

                    free(posNode);

                    if(stTmpNode.parent != posNode)
                    {
                        AdjustNode(pParentOfFreeNode, avlTree);
                    }
                    else
                    {
                        AdjustNode(freeNode, avlTree);
                    }
                   #if  0
                    pParentOfFreeNode = stTmpNode.parent;

                    posNode->lchild->parent = freeNode;
                    posNode->rchild->parent = freeNode;
                    pParentOfFreeNode->lchild = NULL;
                    free(posNode);
                    AdjustNode(pParentOfFreeNode, avlTree);
#endif

                }
                else if(-1 == iNum)
                {
                    /*这个属于异常分支，会指向自己*/
                    //process posNode
                    if(stTmpNode.parent != posNode)
                    {
                        posNode->lchild->parent = freeNode;
                        posNode->rchild->parent = freeNode;

                    }
                    else
                    {
                        stTmpNode.rchild->parent = freeNode;
                        posNode->lchild->parent = freeNode;
                    }
                    //process freeNode
                    if(stTmpNode.parent != posNode)
                    {
                        stTmpNode.rchild->parent  = stTmpNode.parent;
                        stTmpNode.parent->lchild = stTmpNode.rchild;
                    }
                    else
                    {
                        stTmpNode.rchild->parent = freeNode;
                        freeNode->rchild = stTmpNode.rchild;
                    }

                    free(posNode);
                    if(stTmpNode.parent != posNode)
                    {
                        AdjustNode(stTmpNode.parent, avlTree);
                    }
                    else
                    {
                        AdjustNode(freeNode, avlTree);
                    }

                }
            }
        }
    }
    else
    {
        printf("can not find the key .
");
    }
}
void DelNodeTestCase()
{
#if 0
    int arr[5]={10, 8, 14, 12, 15};//del root
    AVLTree *avlTree = InitBTree(arr, 5);
    PRINTTREEINIT(avlTree);

    int delKey = 10;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[1]={10};//del root
    AVLTree *avlTree = InitBTree(arr, 1);
    PRINTTREEINIT(avlTree);

    int delKey = 10;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[2]={10,15};//del root
    AVLTree *avlTree = InitBTree(arr, 2);
    PRINTTREEINIT(avlTree);

    int delKey = 10;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[3]={10,15, 5};//del root
    AVLTree *avlTree = InitBTree(arr, 3);
    PRINTTREEINIT(avlTree);

    int delKey = 10;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif

#if 0
    int arr[3]={10,15, 5};
    AVLTree *avlTree = InitBTree(arr, 3);
    PRINTTREEINIT(avlTree);

    int delKey = 5;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif

#if 0
    int arr[7]={20,15, 25,7, 18, 22,19};
    AVLTree *avlTree = InitBTree(arr, 7);
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[7]={20,15, 25,7, 18, 22,17};
    AVLTree *avlTree = InitBTree(arr, 7);
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[7]={20,15, 25,7, 18, 22,17};
    AVLTree *avlTree = InitBTree(arr, 7);
    PRINTTREEINIT(avlTree);

    int delKey = 18;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[6]={20,15, 25,7, 18, 22};
    AVLTree *avlTree = InitBTree(arr, sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[5]={20,15, 25,7,  22};
    AVLTree *avlTree = InitBTree(arr, sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[13]={20,15, 25,7, 18, 22,30, 5, 9, 16,19,40, 17};
    AVLTree *avlTree = InitBTree(arr,  sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[13]={20,15, 25,7, 18, 22,30, 5, 9, 17,19,40, 16};
    AVLTree *avlTree = InitBTree(arr,  sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif

#if 0
    /*左子树中max叶子节点*/
    int arr[13]={28,20, 40,18,25,30,50,16,19,22,26,60, 17};
    AVLTree *avlTree = InitBTree(arr, 13);
    PRINTTREEINIT(avlTree);

    int delKey = 20;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif

#if 0
    /*左子树中max叶子节点*/
    int arr[13]={28,20, 40,18,25,30,50,17,19,22,26,60, 16};
    AVLTree *avlTree = InitBTree(arr, sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 20;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 0
    int arr[13]={20,15, 25,7, 18, 22,30, 5, 9, 16,19,40, 11};
    AVLTree *avlTree = InitBTree(arr,  sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
/*这个地方调整影响到其他的地方了*/
#if 0
    int arr[13]={20,15, 25,7, 18, 22,30, 5, 11, 16,19,40, 9};
    AVLTree *avlTree = InitBTree(arr,  sizeof(arr)/sizeof(arr[0]));
    PRINTTREEINIT(avlTree);

    int delKey = 15;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif

#if 0
    /*左子树中max非叶子节点*/
    int arr[13]={28,21, 40,18,25,30,50,16,20,22,26,60, 19};
    AVLTree *avlTree = InitBTree(arr, 13);
    PRINTTREEINIT(avlTree);

    int delKey = 21;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif

#if 0
    /*左子树中max非叶子节点*/
    int arr[7]={28,21, 40,20,25,30,18};
    AVLTree *avlTree = InitBTree(arr, 7);
    PRINTTREEINIT(avlTree);

    int delKey = 21;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
#if 1
    /*左子树中max非叶子节点3个节点情况*/
    int arr[6]={28,21, 40,18,25,30};
    AVLTree *avlTree = InitBTree(arr, 7);
    PRINTTREEINIT(avlTree);

    int delKey = 21;
    DeleteNode(avlTree, delKey);
    PRINTTREEDEL(avlTree);
#endif
}
void ConstAVLTree()
{
#if 1
    //int arr[6]={10, 8, 14, 12, 15, 16};//RR
    //int arr[6]={10, 8, 18, 12, 25, 19};//RR
    //int arr[6]={10, 8, 14, 12, 15, 11};//RL(L)
    //int arr[6]={10, 8, 14, 12, 15, 13};//RL(R)
    //int arr[6]={20, 17, 25, 14, 18, 15};//LL(L)
    //int arr[6]={20, 17, 25, 14, 18, 16};//LL(R)
    //int arr[6]={20, 16, 25, 14, 18, 17};//LR(L)
    int arr[6]={20, 16, 25, 14, 18, 19};//LR(R)
    AVLTree *avlTree = InitBTree(arr, sizeof(arr)/sizeof(arr[0]));
    PRINTTREEAVL(avlTree);
    //int arr[12]={25, 14, 30, 8, 20, 28, 39, 7, 9, 18, 22, 19};//LR(R)
    //int arr[12]={25, 14, 30, 8, 20, 28, 39, 7, 9, 18, 22, 17};//LR(L)
    //int arr[12]={25, 14, 30, 8, 20, 28, 39, 7, 9, 18, 22, 6};//LL(L)
    //int arr[12]={25, 10, 35, 8, 15, 29, 40, 27, 33, 38, 45, 26};//RL(L)
    //int arr[12]={25, 10, 35, 8, 15, 29, 40, 27, 33, 38, 45, 50};//RR(L)

    //AVLTree *avlTree = InitBTree(arr, 12);
#endif
}
int main(void)
{
    ConstAVLTree();
    DelNodeTestCase();
    return 0;
}

运行结果：------------------AVL Tree begin-------------
***********TREE View BEGIN***********
18
    16
        14
            *
            &
        &
    20
        19
            *
            &
        25
            *
            &
***********TREE View END ***********


------------------AVL Tree end-------------
------------------init Tree begin-------------
***********TREE View BEGIN***********
28
    21
        18
            *
            19
                *
                &
        25
            *
            &
    40
        30
            *
            &
        &
***********TREE View END ***********


------------------init Tree end-------------

要写的数据结构又少一个哈哈哈哈哈哈