平衡二叉树

程序输入一个字符串（只包含小写字母），请按照字符的输入顺序建立平衡二叉排序树，并分别输出二叉树的先序序列、中序序列和后序序列，最后输出该二叉树向左旋转 90 度后的结构。

例如：向左旋转 90 度后，以每层向里缩进 4 个空格的方式输出，输出结果为：

        i
    g
        f
a
        d
    c
        b

输入：agxnzyimk

输出：
Preorder: xigamknzy
Inorder: agikmnxyz
Postorder: agknmiyzx
Tree:
    z
        y
x
            n
        m
            k
    i
        g

            a

测试输出

agxnzyimk

测试输出

Preorder: xigamknzy
Inorder: agikmnxyz
Postorder: agknmiyzx
Tree:
    z
        y
x
            n
        m
            k
    i
        g
            a

源代码

#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
 
#define MAXSIZE 1000  
  
typedef struct node{  
    int bf;  
    char data;  
    struct node *lchild,*rchild;   /*左右指针*/   
}AVLTNode,* AVLTree;  
  
void  ins_AVLtree(AVLTree  *avlt ,  char  K)  
/*在平衡二叉树中插入元素k，使之成为一棵新的平衡二叉排序树*/  
{  
    AVLTNode *S;  
    AVLTNode *A, *FA, *p, *fp, *B, *C;  
    S=(AVLTree)malloc(sizeof(AVLTNode));  
    S->data=K;   
    S->lchild=S->rchild=NULL;  
    S->bf=0;  
    if (*avlt==NULL)    
        *avlt=S;  
    else   
    {   
    /* 首先查找S的插入位置fp，同时记录距S的插入位置最近且平衡因子不等于0（等于-1或1）的结点A，A为可能的失衡结点*/  
        A=*avlt;  FA=NULL;  
        p=*avlt;  fp=NULL;  
        while  (p!=NULL)  
        {   
            if (p->bf!=0)   
            {  
                A=p; FA =fp;  
            }  
            fp=p;  
            if  (K < p->data)    
                p=p->lchild;  
            else    
                p=p->rchild;  
        }  
        /* 插入S*/  
        if (K < fp->data)   
            fp->lchild=S;  
        else  
            fp->rchild=S;  
        /* 确定结点B，并修改A的平衡因子 */  
        if (K < A->data)  
        {  
            B=A->lchild;  
            A->bf=A->bf+1;  
        }  
        else  
        {  
            B=A->rchild;  
            A->bf=A->bf-1;  
        }  
        /* 修改B到S路径上各结点的平衡因子（原值均为0）*/  
        p=B;  
        while (p!=S)  
        {  
            if  (K < p->data)  
            {  
                p->bf=1;  
                p=p->lchild;  
            }  
            else  
            {  
                p->bf=-1;  
                p=p->rchild;  
            }  
            /* 判断失衡类型并做相应处理 */  
            if  (A->bf==2 && B->bf==1)       /* LL型 */  
            {  
                B=A->lchild;  
                A->lchild=B->rchild;  
                B->rchild=A;  
                A->bf=0;  
                B->bf=0;  
                if (FA==NULL)   
                    *avlt=B;  
                else   
                    if (A==FA->lchild)   
                        FA->lchild=B;  
                    else   
                        FA->rchild=B;  
            }  
            else  
                if (A->bf==2 && B->bf==-1)       /* LR型 */  
                {  
                    B=A->lchild;  
                    C=B->rchild;  
                    B->rchild=C->lchild;  
                    A->lchild=C->rchild;  
                    C->lchild=B;  
                    C->rchild=A;  
                    if (S->data < C->data)  
                    {   
                        A->bf=-1;  
                        B->bf=0;  
                        C->bf=0;  
                    }  
                    else   
                        if (S->data >C->data)  
                        {  
                            A->bf=0;  
                            B->bf=1;  
                            C->bf=0;  
                        }  
                        else  
                        {   
                            A->bf=0;  
                            B->bf=0;  
                        }  
                        if  (FA==NULL)   
                            *avlt=C;  
                        else   
                            if (A==FA->lchild)   
                                FA->lchild=C;  
                            else   
                                FA->rchild=C;  
                }  
                else   
                    if  (A->bf==-2 && B->bf==1)       /* RL型 */  
                    {  
                        B=A->rchild;  
                        C=B->lchild;  
                        B->lchild=C->rchild;  
                        A->rchild=C->lchild;  
                        C->lchild=A;  
                        C->rchild=B;  
                        if (S->data <C->data)   
                        {   
                            A->bf=0;  
                            B->bf=-1;  
                            C->bf=0;  
                        }  
                        else   
                            if (S->data >C->data)  
                            {  
                                A->bf=1;  
                                B->bf=0;  
                                C->bf=0;  
                            }  
                            else   
                            {   
                                A->bf=0;  
                                B->bf=0;  
                            }  
                            if (FA==NULL)    
                                *avlt=C;  
                            else  
                                if (A==FA->lchild)   
                                    FA->lchild=C;  
                                else    
                                    FA->rchild=C;  
                    }  
                    else   
                        if (A->bf==-2 && B->bf==-1)       /* RR型 */  
                        {  
                            B=A->rchild;  
                            A->rchild=B->lchild;  
                            B->lchild=A;  
                            A->bf=0;  
                            B->bf=0;  
                            if (FA==NULL)   
                                *avlt=B;  
                            else  
                                if (A==FA->lchild)  
                                    FA->lchild=B;  
                                else   
                                    FA->rchild=B;  
                        }  
                }  
        }  
}  
  
AVLTree CreateAVLT(AVLTNode *valt)  /*从键盘输入元素的值，创建相应的二叉排序树*/   
{  
    int i=0;  
    char str[MAXSIZE];  
    scanf("%s",str);  
    while(i<strlen(str)){  
        ins_AVLtree(&valt,str[i]);  
        i++;  
    }  
    return(valt);  
}  
  
void PreOrder(AVLTree root)   /*按先序输出节点*/   
{                                
    if(root!=NULL){  
        printf("%c",root->data);  
        PreOrder(root->lchild);  
        PreOrder(root->rchild);  
    }  
}  
  
void InOrder(AVLTree root)   /*按中序输出节点*/  
{      
    if(root!=NULL){  
        InOrder(root->lchild);  
        printf("%c",root->data);  
        InOrder(root->rchild);  
    }  
}  
  
void PostOrder(AVLTree root)  /*按后续输出节点*/    
{    
    if(root!=NULL){  
        PostOrder(root->lchild);  
        PostOrder(root->rchild);  
        printf("%c",root->data);  
    }  
}  
  
void PrintTree(AVLTree bt,int nLayer)  /*竖状输出二叉树*/  
{     
    int i;  
    if(bt==NULL) return;  
    PrintTree(bt->rchild,nLayer+1);   
    for(i=0;i<nLayer;i++)   
        printf("    ");  
    printf("%c\n",bt->data);   
    PrintTree(bt->lchild,nLayer+1);  
}  
  
int main(){  
    AVLTree valt;  
    valt=NULL;  
    valt=CreateAVLT(valt);  
    printf("Preorder: ");  
    PreOrder(valt);  
    printf("\n");  
    printf("Inorder: ");  
    InOrder(valt);  
    printf("\n");  
    printf("Postorder: ");  
    PostOrder(valt);  
    printf("\n");  
    printf("Tree:\n");  
    PrintTree(valt,0);  
}