数据结构学习笔记04树(二叉树、二叉搜索树、平衡二叉树)

一.树

树的基本术语

　　①结点的度（Degree）：结点的子树个数

　　②树的度：树的所有结点中最大的度数

　　③叶结点（Leaf）：度为0的结点

　　④父结点（Parent）：有子树的结点是其子树的根结点的父结点

　　⑤子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点；子结点也称孩子结点。

　　⑥兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点。

　　⑦路径和路径长度：从结点n1到nk的路径为一个结点序列n1 , n2 ,… , nk , ni是 ni+1的父结点。路径所包含边的个数为路径的长度。

　　⑧ 祖先结点(Ancestor)：沿树根到某一结点路径上的所有结点都是这个结点的祖先结点。

　　⑨子孙结点(Descendant)：某一结点的子树中的所有结点是这个结点的子孙。

　   ⑩结点的层次（Level）：规定根结点在1层，其它任一结点的层数是其父结点的层数加1。 12. 树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度。

二.二叉树

二叉树的性质

　　①一个二叉树第 i 层的最大结点数为：2^(i-1) (i>=1)

　　②深度为k的二叉树至多有2^k-1个结点 (i>=1)

　　③对任何非空二叉树 T，若n0表示叶结点的个数、n2是度为2的非叶结点个数，那么两者满足关系n0 = n2 +1    ---> n0+n1+n2 = B + 1 = n0 * 0 + n1 * 1 + n2 * 2 + 1

1.顺序存储结构

完全二叉树：按从上至下、从左到右顺序存储

N个结点的完全二叉树的结点父子关系：

　　①    非根结点（序号i > 1）的父结点的序号[ i / 2]

　　②    结点(序号为i) 的左孩子结点序号 2i，（若2i <=n,否则无左孩子）

　　③    结点(序号为i) 的左孩子结点序号 2i +1，（若2i + 1<=n,否则无右孩子）

非完全二叉树 ---> 补全为完全二叉树

2.链式存储结构(代码：sj4_0)

//二叉树
#include <iostream>
#include <cstdio>
#include <stdlib.h>
#include <stack>
#include <queue>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -1

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType;/* ElemType类型根据实际情况而定，这里假设为int*/

typedef struct BinTNode *BinTree;
struct BinTNode
{
    TElemType data;
    BinTree left;
    BinTree right;
}; 

Status CreatBiTree(BinTree &T);
Status PreOrderTraverse(BinTree T);
Status InOderTraverse(BinTree T);
Status PostOrderTraverse(BinTree T);

Status StackPreOrderTraverse(BinTree T);
Status StackInOrderTraverse(BinTree T);
Status StackPostOrderTraverse(BinTree T);

Status LevelOrderTraverse(BinTree T);

int PostOrderGetHeight(BinTree T);

Status InitBiTree(BinTree &T);
Status DestroyBiTree(BinTree &T);
Status ClearBiTree(BinTree &T);
bool BiTreeEmpty(BinTree T);
TElemType Root(BinTree T);
TElemType Value(BinTree p);
void Assign(BinTree p,TElemType value);
 
/*按先序次序输入二叉树中的结点值，负数表示空树 
构造二叉链表表示的二叉树*/
Status CreatBiTree(BinTree &T)        
{
    TElemType data;
    scanf("%d",&data);
    if(data < 0 ) 
        T = NULL;
    else {
        if( !(T = (BinTree)malloc(sizeof(BinTNode))) )
            exit(OVERFLOW); 
        T->data = data;
        CreatBiTree(T->left);
        CreatBiTree(T->right);
    }
    return OK;
}

//递归实现先序遍历 
Status PreOrderTraverse(BinTree T)
{
    if(T) {
        printf("%5d", T->data);
        PreOrderTraverse(T->left);
        PreOrderTraverse(T->right);
    }
    return OK;
}
//递归实现中序遍历 
Status InOderTraverse(BinTree T)
{
    if(T) {
        PreOrderTraverse(T->left);
        printf("%5d", T->data);
        PreOrderTraverse(T->right);
    }
    return OK;
}
//递归实现后序遍历  
Status PostOrderTraverse(BinTree T)
{
    if(T) {
        PreOrderTraverse(T->left);
        PreOrderTraverse(T->right);
        printf("%5d", T->data);
    }
    return OK;
}

//非递归实现先序遍历:堆栈 
Status StackPreOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;  
    BinTree BT = T;
    stack<BinTree> stack;
    while(BT || !stack.empty() ) {
        while(BT) {            //一直向左将沿途结点压入堆栈 
            printf("%5d",BT->data);    //访问打印结点 
            stack.push(BT);
            BT = BT->left;
        }
        if( !stack.empty() ) {    
            BT = stack.top();        //记录弹出结点 
            stack.pop();
            BT = BT->right;         //转向右子树 
        }
    }
    return OK;    
}

//非递归实现中序遍历:堆栈 
Status StackInOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;  
    BinTree BT = T;
    stack<BinTree> stack;
    while(BT || !stack.empty() ) {
        while(BT) {            //一直向左将沿途结点压入堆栈 
            stack.push(BT);
            BT = BT->left;
        }
        if( !stack.empty() ) {        //////
            BT = stack.top();        //记录弹出结点 
            stack.pop();
            printf("%5d",BT->data);    //访问打印结点 
            BT = BT->right;         //转向右子树 
        }
    }
    return OK;    
}

//非递归实现后序遍历:堆栈 
/*后序遍历LRG：第一遍入栈，G再第二遍被遍历到时，若有右孩子，则入栈（等待第三次遍历)；
如无右孩子，或右孩子已被访问，则访问G结点。*/ 
Status StackPostOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;  
    BinTree BT = T;
    stack<BinTree> stack;
    BinTree lastNode = NULL, currentNode = NULL;//lastNode记录被访问过的前一个结点 
    while( BT || !stack.empty() ) {
        while(BT) {                //一直向左将沿途结点压入堆栈 
            stack.push(BT);
            BT = BT->left;
        }
        while( !stack.empty() ) {
            currentNode = stack.top();    //当前节点
            stack.pop();                //出栈
            if( currentNode->right == NULL || currentNode->right == lastNode) {//无右子树或右子树已被访问     
                printf("%5d",currentNode->data);
                lastNode = currentNode;
            }else {        //右子树未被访问过 
                stack.push(currentNode);
                currentNode = currentNode->right;
                while(currentNode) {
                    stack.push(currentNode);
                    currentNode = currentNode->left;
                }
            }
        }
    }
    return OK;
}

//层序遍历：队列 
Status LevelOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;
    BinTree BT = T;
    queue<BinTree> queue;
    queue.push(BT);
    while( !queue.empty() ) {
        BinTree temp = queue.front();
        printf("%5d", temp->data);
        queue.pop();
        if(temp->left)
            queue.push(temp->left);
        if(temp->right)
            queue.push(temp->right);
    }
    printf("
");
    return OK;
}

//后序遍历求树深度（高） 
int PostOrderGetHeight(BinTree T)
{
    int leftHeight, rightHeight, maxHeight;
    if(T) {
        leftHeight = PostOrderGetHeight(T->left);    //左子树深度 
        rightHeight = PostOrderGetHeight(T->right);    //右子树深度 
        maxHeight = leftHeight > rightHeight ? leftHeight : rightHeight;
        return (maxHeight+1);    //返回树的深度 
    }
    else 
        return 0;//空树深度为0 
} 
 
//构造空二叉树T 
Status InitBiTree(BinTree &T)
{
    T = NULL;
    return OK;
}
//销毁二叉树T 
Status DestroyBiTree(BinTree &T)
{
    if(T) {
        if(T->left)
            DestroyBiTree(T->left);
        if(T->right)
            DestroyBiTree(T->right);
        free(T);    //释放该结点 
        T = NULL;    //T置空 
    }
    return OK;
}
/*清空二叉树T 
清空和销毁有什么区别么*/ 
Status ClearBiTree(BinTree &T)
{
    if(T) {
        if(T->left)
            DestroyBiTree(T->left);
        if(T->right)
            DestroyBiTree(T->right);
        free(T);    //释放该结点 
        T = NULL;    //T置空 
    }
    return OK;
} 

bool BiTreeEmpty(BinTree T)
{
    if( !T )
        return true;
    else
        return false;
}

//返回T的根
TElemType Root(BinTree T)
{ 
    if(BiTreeEmpty(T))
        return -1;
    else
        return T->data;
}

//返回p所指结点的值 
TElemType Value(BinTree p)
{
    return p->data;
}

// 给p所指结点赋值为value 
void Assign(BinTree p,TElemType value)
{
    p->data=value;
}



int main()
{
    BinTree T;
    CreatBiTree(T);
    printf("先序递归遍历：  "); 
    PreOrderTraverse(T);
    printf("
先序非递归遍历："); 
    StackPreOrderTraverse(T);
    
    printf("
中序递归遍历：  "); 
    InOderTraverse(T);
    printf("
中序非递归遍历："); 
    StackInOrderTraverse(T);
    
    printf("
后序递归遍历：  "); 
    PostOrderTraverse(T);
    printf("
后序非递归遍历："); 
    StackPostOrderTraverse(T);
    
    printf("
层序遍历：      "); 
    LevelOrderTraverse(T);
    printf("
树的高度：%d
",PostOrderGetHeight(T)); 
    if(BiTreeEmpty(T))
        printf("空
");
    else
        printf("不空
");
    printf("树的根：%d
",Root(T)); 
    
        

    return 0;
}

先序GLR：第一次遇到该结点则输出。

中序LGR：第二次遇到该结点则输出。

后序LRG：第三次遇到该结点则输出。

typedef struct BinTNode *BinTree;

struct BinTNode

{

       TElemType data;

       BinTree left;

       BinTree right;

};

先序递归算法

//递归实现先序遍历 
Status PreOrderTraverse(BinTree T)
{
    if(T) {
        printf("%5d", T->data);
        PreOrderTraverse(T->left);
        PreOrderTraverse(T->right);
    }
    return OK;
}

先序遍历非递归遍历算法

　　①遇到一个结点，访问打印它，将其压栈，并遍历它的左子树

　　②当左子树遍历结束后，从栈顶弹出这个结点

　　③然后按其右指针再去先序遍历该结点的右子树

Status StackPreOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;  
    BinTree BT = T;
    stack<BinTree> stack;
    while(BT || !stack.empty() ) {
        while(BT) {            //一直向左将沿途结点压入堆栈 
            printf("%5d",BT->data);    //访问打印结点 
            stack.push(BT);
            BT = BT->left;
        }
        if( !stack.empty() ) {    
            BT = stack.top();        //记录弹出结点 
            stack.pop();
            BT = BT->right;         //转向右子树 
        }
    }
    return OK;    
}

中序遍历非递归遍历算法

　　①遇到一个结点，就把它压栈，并遍历它的左子树

　　②当左子树遍历结束后，从栈顶弹出这个结点并访问它

　　③然后按其右指针再去中序遍历该结点的右子树

//非递归实现中序遍历:堆栈 
Status StackInOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;  
    BinTree BT = T;
    stack<BinTree> stack;
    while(BT || !stack.empty() ) {
        while(BT) {            //一直向左将沿途结点压入堆栈 
            stack.push(BT);
            BT = BT->left;
        }
        if( !stack.empty() ) {        //////
            BT = stack.top();        //记录弹出结点 
            stack.pop();
            printf("%5d",BT->data);    //访问打印结点 
            BT = BT->right;         //转向右子树 
        }
    }
    return OK;    
}

后序遍历非递归算法

　　后序遍历LRG：第一遍入栈，G再第二遍被遍历到时，若有右孩子，则入栈（等待第三次遍历)；如无右孩子，或右孩子已被访问，则访问G结点。

//非递归实现后序遍历:堆栈 
Status StackPostOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;  
    BinTree BT = T;
    stack<BinTree> stack;
    BinTree lastNode = NULL, currentNode = NULL;//lastNode记录被访问过的前一个结点 
    while( BT || !stack.empty() ) {
        while(BT) {                //一直向左将沿途结点压入堆栈 
            stack.push(BT);
            BT = BT->left;
        }
        while( !stack.empty() ) {
            currentNode = stack.top();    //当前节点
            stack.pop();                //出栈
            if( currentNode->right == NULL || currentNode->right == lastNode) {//无右子树或右子树已被访问     
                printf("%5d",currentNode->data);
                lastNode = currentNode;
            }else {        //右子树未被访问过 
                stack.push(currentNode);
                currentNode = currentNode->right;
                while(currentNode) {
                    stack.push(currentNode);
                    currentNode = currentNode->left;
                }
            }
        }
    }
    return OK;
}

层序遍历算法：先根结点入队，然后

　　①从队列取出一个元素

　　②访问打印该元素所指结点

　　③若该元素有左右孩子，则左右孩子顺序入队

//层序遍历：队列 
Status LevelOrderTraverse(BinTree T)
{
    if(T == NULL)
        return ERROR;
    BinTree BT = T;
    queue<BinTree> queue;
    queue.push(BT);
    while( !queue.empty() ) {
        BinTree temp = queue.front();
        printf("%5d", temp->data);
        queue.pop();
        if(temp->left)
            queue.push(temp->left);
        if(temp->right)
            queue.push(temp->right);
    }
    printf("
");
    return OK;
}

三.二叉搜索树(二叉排序树 二叉查找树)（代码：sj4_1）

//二叉搜索树（BST） 
#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define OVERFLOW -1 

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType;/* ElemType类型根据实际情况而定，这里假设为int*/


typedef struct BinTNode *BSTree;
struct BinTNode
{
    TElemType data;
    BSTree left;
    BSTree right;
}; 
//查找X,若成功返回结点地址，失败返回NULL 
BSTree Find(TElemType X,BSTree BST)
{
    while(BST) {
        if(X < BST->data) 
            BST = BST->left;
        else if(X > BST->data)
            BST = BST->right;
        else
            return BST;
    }
    return NULL;
}
//从二叉搜索树BST中查找并返回最小元素所在结点的地址 
BSTree FindMin(BSTree BST)
{
    if(BST)
        while(BST->left) 
            BST = BST->left;
    return BST;    
}

//从二叉搜索树BST中查找并返回最大元素所在结点的地址
BSTree FindMax(BSTree BST)
{
    if(BST)
        while(BST->right) 
            BST = BST->right;
    return BST;
}
 
//插入结点X 
BSTree Insert(TElemType X,BSTree BST)
{
    if(!BST) {            //空则建结点 
        BST = (BSTree)malloc(sizeof(struct BinTNode));
        BST->data = X;
        BST->left = BST->right = NULL;
    }else {
        if(X > BST->data)        //X大于该结点，递归插入右子树 
            Insert(X,BST->right);
        else if(X < BST->data)    //X小于该结点，递归插入做子树 
            Insert(X,BST->left);
        //相等，已存在，什么都不做 
    }
    return BST;
}

//删除结点X 
BSTree Delete(TElemType X,BSTree BST)
{
    if(!BST) {
        printf("未找到要删除的结点
"); 
        return ERROR;
    }
    if(X > BST->data) 
        BST->right = Delete(X,BST->right);
    else if(X < BST->data)
        BST->left = Delete(X,BST->left);
    else {    //找到要删除的结点 
        if(BST->left && BST->right) {        //要删除结点有左右两个孩子 
            BSTree Temp = FindMin(BST);    //在右子树中找到最小元素填充要删除元素 
            BST->data = Temp->data;
            BST->right = Delete(Temp->data,BST->right);//删除最小元素 
        }else {                        //要删除结点只有一个孩子或没有孩子 
            BSTree Temp = BST; 
            if(!BST->left)            //如果左孩子空
                BST = BST->right;
            if(!BST->right)            //如果右孩子空
                BST = BST->left;
            free(Temp); 
        }
    }
    return BST;
} 

二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

　　①非空左子树的所有键值小于其根结点的键值。

　　② 非空右子树的所有键值大于其根结点的键值。

　　③ 左、右子树都是二叉搜索树。

BSTree Find(TElemType X,BSTree BST)：从二叉搜索树BST中查找元素X，返回其所在结点的地址；

BSTree FindMin(BSTree BST)从二叉搜索树BST中查找并返回最小元素所在结点的地址；

BSTree FindMax(BSTree BST)：从二叉搜索树BST中查找并返回最大元素所在结点的地址。

BSTree Insert(TElemType X,BSTree BST)

BSTree Delete(TElemType X,BSTree BST)

1.二叉搜索树的查找

算法思路：查找从根结点开始，如果树为空，返回NULL

　　若搜索树非空，则根结点关键字和X进行比较，并进行不同处理：

　　若X小于根结点键值，只需在左子树中继续搜索；

　　如果X大于根结点的键值，在右子树中进行继续搜索；

　　若两者比较结果是相等，搜索完成，返回指向此结点的指针。

最大元素一定是在树的最右分枝的端结点上

最小元素一定是在树的最左分枝的端结点上

//查找X,若成功返回结点地址，失败返回NULL 
BSTree Find(TElemType X,BSTree BST)
{
    while(BST) {
        if(X < BST->data) 
            BST = BST->left;
        else if(X > BST->data)
            BST = BST->right;
        else
            return BST;
    }
    return NULL;
}
//从二叉搜索树BST中查找并返回最小元素所在结点的地址 
BSTree FindMin(BSTree BST)
{
    if(BST)
        while(BST->left) 
            BST = BST->left;
    return BST;    
}

//从二叉搜索树BST中查找并返回最大元素所在结点的地址
BSTree FindMax(BSTree BST)
{
    if(BST)
        while(BST->right) 
            BST = BST->right;
    return BST;
}

2.二叉搜索树的删除

　　三种情况：

　　　　①要删除的是叶结点：直接删除，并再修改其父结点指针---置为NULL

　　　　②要删除的结点只有一个孩子结点: 将其父结点的指针指向要删除结点的孩子结点

　　　　③要删除的结点有左、右两棵子树： 用另一结点替代被删除结点：右子树的最小元素 或者 左子树的最大元素

//删除结点X 
BSTree Delete(TElemType X,BSTree BST)
{
    if(!BST) {
        printf("未找到要删除的结点
"); 
        return ERROR;
    }
    if(X > BST->data) 
        BST->right = Delete(X,BST->right);
    else if(X < BST->data)
        BST->left = Delete(X,BST->left);
    else {    //找到要删除的结点 
        if(BST->left && BST->right) {        //要删除结点有左右两个孩子 
            BSTree Temp = FindMin(BST);    //在右子树中找到最小元素填充要删除元素 
            BST->data = Temp->data;
            BST->right = Delete(Temp->data,BST->right);//删除最小元素 
        }else {                        //要删除结点只有一个孩子或没有孩子 
            BSTree Temp = BST; 
            if(!BST->left)            //如果左孩子空
                BST = BST->right;
            if(!BST->right)            //如果右孩子空
                BST = BST->left;
            free(Temp); 
        }
    }
    return BST;
} 

四.平衡二叉树(Balanced Binary Tree)(AVL树)(代码：sj4_2)

//平衡二叉树 AVL 
#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
typedef struct AVLNode{
    ElementType data; /* 结点数据 */
    AVLTree left;     /* 指向左子树 */
    AVLTree right;    /* 指向右子树 */
    int height;       /* 树高 */
};
 
int Max ( int a, int b )
{
    return a > b ? a : b;
}

int GetHeight( Position p )
{
    if(!p)
        return -1;
    return p->height;
}

/* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */ 
/* 注意：A必须有一个左子结点B */    
AVLTree SingleLeftRotation ( AVLTree A )
{
    AVLTree B = A->left;
    A->left = B->right;
    B->right = A;
    A->height = Max( GetHeight(A->left), GetHeight(A->right) ) + 1;
    B->height = Max( GetHeight(B->left), A->height ) + 1;
  
    return B;
}
/* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */ 
/* 注意：A必须有一个右子结点B */
AVLTree SingleRightRotation ( AVLTree A )
{ 
    AVLTree B = A->right;
    A->right = B->left;
    B->left = A;
    A->height = Max( GetHeight(A->left), GetHeight(A->right) ) + 1;
    B->height = Max( A->height, GetHeight(B->right) ) + 1;
  
    return B;
}

/* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
/* 将A、B与C做两次单旋，返回新的根结点C */ 
AVLTree DoubleLeftRightRotation ( AVLTree A )
{ 
    /* 将B与C做右单旋，C被返回 */
    A->left = SingleRightRotation(A->left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}

/* 将A、B与C做两次单旋，返回新的根结点C */ 
/* 注意：A必须有一个右子结点B，且B必须有一个左子结点C */
AVLTree DoubleRightLeftRotation ( AVLTree A )
{ 
    /* 将B与C做右单旋，C被返回 */
    A->right = SingleLeftRotation(A->right);
    /* 将A与C做左单旋，C被返回 */
    return SingleRightRotation(A);
}

/* 将X插入AVL树T中，并且返回调整后的AVL树 */
AVLTree Insert( AVLTree T, ElementType X )
{ 
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->data = X;
        T->height = 0;
        T->left = T->right = NULL;
    } /* if (插入空树) 结束 */
 
    else if ( X < T->data ) {
        T->left = Insert( T->left, X);/* 插入T的左子树 */
        if ( GetHeight(T->left)-GetHeight(T->right) == 2 ) /* 如果需要左旋 */
            if ( X < T->left->data ) 
               T = SingleLeftRotation(T);      //左单旋 LL
            else 
               T = DoubleLeftRightRotation(T); //左-右双旋LR
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->data ) {
        T->right = Insert( T->right, X );/* 插入T的右子树 */
        if ( GetHeight(T->left)-GetHeight(T->right) == -2 )/* 如果需要右旋 */
            if ( X > T->right->data ) 
               T = SingleRightRotation(T);     //右单旋 RR
            else 
               T = DoubleRightLeftRotation(T); //右-左双旋 RL
    } /* else if (插入右子树) 结束 */
 
    /*else X == T->Data，无须插入 */
    T->height = Max( GetHeight(T->left), GetHeight(T->right) ) + 1;    //更新树高 
     
    return T;
}

int main()
{
    int N, data;
    AVLTree T;
    scanf("%d",&N);
    for(int i = 0; i < N; i++) {
        scanf("%d",&data);
        T = Insert(T,data);
    }
    printf("%d
",T->data);
    return 0;
}

平衡因子（Balance Factor，简称BF）: BF(T) = hL-hR，

平衡二叉树：空树，或者 任一结点左、右子树高度差的绝对值不超过1，即|BF(T) |≤ 1

1.LL

/* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */ 
/* 注意：A必须有一个左子结点B */    
AVLTree SingleLeftRotation ( AVLTree A )
{
    AVLTree B = A->left;
    A->left = B->right;
    B->right = A;
    A->height = Max( GetHeight(A->left), GetHeight(A->right) ) + 1;
    B->height = Max( GetHeight(B->left), A->height ) + 1;
  
    return B;
}

2.RR

/* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */ 
/* 注意：A必须有一个右子结点B */
AVLTree SingleRightRotation ( AVLTree A )
{ 
    AVLTree B = A->right;
    A->right = B->left;
    B->left = A;
    A->height = Max( GetHeight(A->left), GetHeight(A->right) ) + 1;
    B->height = Max( A->height, GetHeight(B->right) ) + 1;
  
    return B;
}

3.LR

/* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
/* 将A、B与C做两次单旋，返回新的根结点C */ 
AVLTree DoubleLeftRightRotation ( AVLTree A )
{ 
    /* 将B与C做右单旋，C被返回 */
    A->left = SingleRightRotation(A->left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}

4.RL

/* 将A、B与C做两次单旋，返回新的根结点C */ 
/* 注意：A必须有一个右子结点B，且B必须有一个左子结点C */
AVLTree DoubleRightLeftRotation ( AVLTree A )
{ 
    /* 将B与C做右单旋，C被返回 */
    A->right = SingleLeftRotation(A->right);
    /* 将A与C做左单旋，C被返回 */
    return SingleRightRotation(A);
}

5.insert

/* 将X插入AVL树T中，并且返回调整后的AVL树 */
AVLTree Insert( AVLTree T, ElementType X )
{ 
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->data = X;
        T->height = 0;
        T->left = T->right = NULL;
    } /* if (插入空树) 结束 */
 
    else if ( X < T->data ) {
        T->left = Insert( T->left, X);/* 插入T的左子树 */
        if ( GetHeight(T->left)-GetHeight(T->right) == 2 ) /* 如果需要左旋 */
            if ( X < T->left->data ) 
               T = SingleLeftRotation(T);      //左单旋 LL
            else 
               T = DoubleLeftRightRotation(T); //左-右双旋LR
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->data ) {
        T->right = Insert( T->right, X );/* 插入T的右子树 */
        if ( GetHeight(T->left)-GetHeight(T->right) == -2 )/* 如果需要右旋 */
            if ( X > T->right->data ) 
               T = SingleRightRotation(T);     //右单旋 RR
            else 
               T = DoubleRightLeftRotation(T); //右-左双旋 RL
    } /* else if (插入右子树) 结束 */
 
    /*else X == T->Data，无须插入 */
    T->height = Max( GetHeight(T->left), GetHeight(T->right) ) + 1;    //更新树高 
     
    return T;
}