二叉排序树（又叫二叉查找树、二叉搜索树）的操作集及平衡二叉排序树

　　二叉排序树或者是一棵空树；或者是具有如下特征的二叉树：若它的左子树不空，则左子树上所有结点的值均小于根结点的值；若它的右子树不空，则右子树上所有结点的值均大于根结点的值；它的左右子树也都分别是二叉排序树；二叉排序树的定义，是一个递归定义的过程；对二叉排序树进行中序遍历，遍历结果恰好是一个有序的线性序列，这也是它被称为二叉排序树的由来；

　　二叉排序树的查找，若给定值等于根结点的关键字，则查找成功；如果给定值小于根结点的关键字，则继续在左子树上进行查找；若给定值大于根结点的关键字，则继续在右子树上进行查找；若二叉排序树为空则查找失败；查找成功的路径，从根结点出发，沿着左分支或右分支逐层向下直至关键字等于给定值的结点；查找不成功的路径，从根结点出发，沿着左分支或右分支逐层向下直至指针指向空树为止；

　　二叉排序树插入结点的位置，就是查找失败的位置；插入操作在查找不成功时才进行，如果二叉排序树为空树，则新插入的结点为新的根结点；否则，新插入的结点必为一个新的叶子结点，其插入位置由查找过程得到；

　　二叉排序树，是在插入的基础上生成的，二叉排序树的生成过程就是结点序列的插入过程；二叉排序树的形态完全由一个输入序列决定，一个无序序列可以通过构造一棵二叉排序树而得到一个有序序列；

　　中序遍历二叉排序树可以得到关键字有序序列；在构造二叉排序树时，每次插入的新结点都是新的叶子结点，所以进行插入时不必移动其他结点；二叉排序树不但拥有类似于折半查找的特性，又采取了链表作为存储结构，因此是动态查找表的一种适宜表示；

　　二叉排序树的删除和插入相反，删除在查找成功之后进行，并且要求在删除二叉排序树上某个结点之后，仍然保持二叉排序树的特性；删除结点分三种情况，结点有左右二个孩子，有左孩子没有右孩子，有右孩子没有左孩子，左右孩子都没有；查找不到删除的结点删除不成功；被删除结点为叶子结点即没有左右孩子，修改其父结点的指针域就可以了，即该结点的指针赋值为NULL；被删除结点有左或右一个孩子的，修改其父结点的指针域，即该结点的指针由其子结点指针覆盖；被删除结点有左右两个孩子的，查找其右子树的最小值结点，右子树的最小值结点的值赋值给该结点，删除右子树的最小值结点，或者查找其左子树的最大值的结点，左子树的最大值结点的值赋值给该结点，删除左子树的最大值结点；

　　一、排序树操作集

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode
{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

void PreorderTraversal( BinTree BT );
void InorderTraversal( BinTree BT );

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );


int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST = NULL;
    scanf("%d", &N);
    for ( i=0; i<N; i++ )
    {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Preorder:");
    PreorderTraversal(BST);
    printf("\n");
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for( i=0; i<N; i++ )
    {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found\n", X);
        else
        {
            printf("%d is found\n", Tmp->Data);
            if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
            if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for( i=0; i<N; i++ )
    {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:");
    InorderTraversal(BST);
    printf("\n");

    return 0;
}

// 插入
BinTree Insert( BinTree BST, ElementType X )
{
    if(!BST)   // 如果为空，创建新结点
    {
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    else
    {
        if(X < BST->Data)
            BST->Left = Insert(BST->Left,X);
        else if(BST->Data < X)
            BST->Right = Insert(BST->Right,X);
    }
    return BST;
}

// 删除
BinTree Delete( BinTree BST, ElementType X )
{
    BinTree tmp;
    if(!BST)
    {
        printf("Not Found\n");
        return BST;
    }
    else
    {
        if(X < BST->Data)
            BST->Left = Delete(BST->Left,X);
        else if(BST->Data < X)
            BST->Right = Delete(BST->Right,X);
        else   // 找到要删除结点
        {
            if(BST->Left && BST->Right)   // 如果该结点有左右儿子
            {
                tmp = FindMin(BST->Right);
                BST->Data = tmp->Data;
                BST->Right = Delete(BST->Right,tmp->Data);
            }
            else
            {
                tmp = BST;
                if(BST->Left && !BST->Right)
                    BST = BST->Left;
                else if(!BST->Left && BST->Right)
                    BST = BST->Right;
                else
                    BST = NULL;
                free(tmp);
            }
        }
    }
    return BST;
}

// 寻找值最小结点
Position FindMin( BinTree BST )
{
    if(BST)
        while(BST->Left)
            BST = BST->Left;
    return BST;
}

// 寻找值最大结点
Position FindMax( BinTree BST )
{
    if(BST)
        while(BST->Right)
            BST = BST->Right;
    return BST;
}

// 查找
Position Find( BinTree BST, ElementType X )
{
    if(!BST)
    {
        return NULL;
    }
    else if(X < BST->Data)
        return Find(BST->Left,X);
    else if(BST->Data < X)
        return Find(BST->Right,X);
    else
        return BST;
}

// 先序遍历
void PreorderTraversal( BinTree BT )
{
    if(BT)
    {
        printf(" %d",BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}
// 中序遍历
void InorderTraversal( BinTree BT )
{
    if(BT)
    {

        InorderTraversal(BT->Left);
        printf(" %d",BT->Data);
        InorderTraversal(BT->Right);
    }
}

　　二、判断是否同一棵排序树

#include <stdio.h>
#include <malloc.h>
/* 树结点定义 */
typedef struct TreeNode *Tree;
struct TreeNode {
    int v;
    Tree Left, Right;
    int flag; /* 判别结点是否访问过的标记 */
};

/* 函数声明 
   1.创建一个树结点
   2.插入一个树结点
   3.创建一棵树
   4.检查树结点是否访问过
   5.判断是否同一棵树
   6.清除树中各结点的flag标记
   7.释放树的空间
*/
Tree NewNode( int V );
Tree Insert( Tree T, int V );
Tree MakeTree( int N );
int check ( Tree T, int V );
int Judge( Tree T, int N );
void ResetT ( Tree T );
void FreeTree ( Tree T );

/* 主程序 */
int main()
{
    int N, L, i;
    Tree T; /* 创建一个树的空结点 */
    scanf("%d", &N);
    while (N) 
    {
        scanf("%d", &L);
        T = MakeTree(N); /* 创建一棵N个结点的树 */
        for (i=0; i<L; i++) 
        {   /* 判断是否同一棵树 */
            if (Judge(T, N)) printf("Yes\n");
            else printf("No\n");
            ResetT(T); /*清除T中的标记flag*/
        }
        FreeTree(T); /* 释放上面的树空间 */
        scanf("%d", &N);
    }
    return 0; 
}
/* 创建一个树结点 */
Tree NewNode( int V )
{ 
    Tree T = (Tree)malloc(sizeof(struct TreeNode));
    T->v = V;
    T->Left = T->Right = NULL;
    T->flag = 0;
    return T;
}
/* 插入一个树结点 */
Tree Insert( Tree T, int V )
{
    if ( !T ) T = NewNode(V);
    else 
    {
        if ( V > T->v )
            T->Right = Insert( T->Right, V );
        else
            T->Left = Insert( T->Left, V );
    }
    return T;
}
/* 创建一棵N个结点的树 */
Tree MakeTree( int N )
{ 
    Tree T;
    int i, V;
    scanf("%d", &V);
    T = NewNode(V); /*  */
    for (i=1; i<N; i++) 
    {
        scanf("%d", &V);
        T = Insert(T, V); /*  */
    }
    return T;
}
/* 判断树的结点是否访问过 */
int check ( Tree T, int V )
{
    if ( T->flag ) 
    {
        if ( V<T->v ) return check(T->Left, V);
        else if ( V>T->v ) return check(T->Right, V);
        else return 0;
    }
    else 
    {
        if ( V==T->v ) 
        {
            T->flag = 1;
            return 1;
        }
        else return 0;
    }
}
/* 判断是否同一棵树 */
int Judge( Tree T, int N )
{
    int i, V, flag = 0;
    /* flag,  0代表目前还一致, 1代表已经不一致*/
    scanf("%d", &V);
    if ( V!=T->v ) flag = 1;
    else T->flag = 1;
    for (i=1; i<N; i++) 
    {
        scanf("%d", &V);/* 读取结点的V */
        if ( (!flag) && (!check(T, V)) ) flag = 1;
    }
    return !flag; /* 1代表已经不一致 */
}
/* 清除T中各结点的flag标记 */
void ResetT ( Tree T ) 
{
    if (T->Left) ResetT(T->Left);
    if (T->Right) ResetT(T->Right);
    T->flag = 0;
}
/* 释放T的空间 */
void FreeTree ( Tree T ) 
{
    if (T->Left) FreeTree(T->Left);
    if (T->Right) FreeTree(T->Right);
    free(T);
}

/* 
测试用例
4 2
3 1 4 2
3 4 1 2
3 2 4 1
2 1
2 1
1 2 0 
*/

　　三、排序树非递归操作

Position IterFind( ElementType X, BinTree BST ) 
{     
    while( BST ) 
    {         
        if( X > BST->Data )       
            BST = BST->Right; /*向右子树中移动，继续查找*/         
        else if( X < BST->Data )    
            BST = BST->Left;  /*向左子树中移动，继续查找*/         
        else /* X == BST->Data */             
            return BST; /*查找成功，返回结点的找到结点的地址*/     
    }     
    return NULL; /*查找失败*/ 
}

BinTree Delete( BinTree BST, KeyType Key )
{
    BinTree P,F,S,Q;
    P = BST;
    F = NULL; /* P的前驱结点指针 */
    
    while(P)
    {
        if(P->Data == Key) /* 找到了 */
            break;
        F = P; /* 保存P指针 */
        if(P->Data > Key) 
            P = P->Left; /* 左子树找 */
        else
            P = P->Right; /* 右子树找 */
    }
    
    if(P == NULL)  /* 没找到返回 */
        return BST;
        
    if(P->Left == NULL) /* 删除结点的左子树为空 */
    {
        if(F == NULL) /* 如果删除的是根结点 */
            BST = P->Right;  /* P的右子树指针赋值给根结点指针 */
        else if(F->Left == P) /* 如果删除结点是其父结点的左孩子 */
            F->Left = P->Right;/* 删除结点的右孩子指针赋值给其父结点的左孩子 */
        else
            F->Right = P->Right; 
        free(P); /* 删除结点 */
    }
    else
    {
        Q = P; /* P指针赋值给Q */
        S = P->Left; /* P的左孩子指针赋值给S */
        while(S->Right) /* 向右找右子树的最大值S->Data */
        {
            Q = S; /* Q为S的前驱结点 */
            S = S->Right;
        }
        if(Q == P) /* 如果P左子树S的右子树为空 */
            Q->Left = S->Left; 
        else
            Q->Right = S->Left;
        P->Data = S->Data;
        free(S);
    }
    return BST;
}

　　四、平衡二叉树

　　平衡因子（Balance Factor，简称BF）: BF(T) = hL-hR，其中hL和hR分别为T的左、右子树的高度；平衡二叉树Balanced Binary Tree，AVL树 :  空树，或者任一结点左、右子树高度差的绝对值不超过1，即|BF(T) |≤ 1 ；给定结点数为 n 的AVL树的 最大高度为O(log2n) ；设 n_h 是高度为h( h>= 0)的平衡二叉树的最小结点数，n_h = n_h-1 + n_h-2 + 1 ，n_h = F_h+2 - 1， (F_h+2，斐波那契序列)，1，2，4，7，12，20，...

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

AVLTree GetHeight(AVLTree A){
    if(!A) return -1;
    return A->Height;
}

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

AVLTree SingleRightRotation ( AVLTree A )
{ /* 注意：A必须有一个右子结点B */
  /* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */     
 
    AVLTree B = A->Right;
    A->Right = B->Left;
    B->Left = A;
    A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
    B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
  
    return B;
}
 
AVLTree DoubleRightLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个右子结点B，且B必须有一个左子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
     
    /* 将B与C做右单旋，C被返回 */
    A->Right = SingleLeftRotation(A->Right);
    /* 将A与C做右单旋，C被返回 */
    return SingleRightRotation(A);
}
 
AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    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的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */
 
    /* else X == T->Data，无须插入 */
 
    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
     
    return T;
}

#include <stdio.h>
#include <malloc.h>

typedef int ElementType;
typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode{
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};

/* AVL树左右单旋\左右双旋\右左双旋\插入 */
int GetHeight( AVLTree A ); /* 树高 */
int Max ( int a, int b );   /* 结点数据大小 */
AVLTree SingleLeftRotation ( AVLTree A );
AVLTree SingleRightRotation ( AVLTree A ); 
AVLTree DoubleLeftRightRotation ( AVLTree A );
AVLTree DoubleRightLeftRotation ( AVLTree A );
AVLTree Insert( AVLTree T, ElementType X );
 
/* 主程序 */
int main()
{
    AVLTree AVLT = NULL;
    int N, i;
    ElementType X;
    scanf("%d", &N);
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        AVLT = Insert(AVLT, X);
    }
    printf("%d\n", AVLT->Data);
    return 0; 
}

/* 树高 */
int GetHeight(AVLTree A)
{
    if(!A) return -1;
    return A->Height;
}

/* 树数据大小 */
int Max ( int a, int b )
{
    return a > b ? a : b;
}

/* 左单旋 */
AVLTree SingleLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */     
 
    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;
}

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

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

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

/* 插入 */
AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    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的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */
 
    /* else X == T->Data，无须插入 */
 
    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
     
    return T;
}

 　   五、判断完全二叉树( 循环队列 \  层序遍历 \ 树结构 \ 队列结构 )

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

/* 树结点 */
typedef struct TreeNode *BinTree;
typedef struct TreeNode TreeNode;
struct TreeNode{
    int Data, ID;
    BinTree Left;
    BinTree Right;
};

/* 顺序循环队列*/
#define MAXSIZE  21 //最大队列长度 N 
typedef struct QNode *Queue; 
struct QNode {
    BinTree* Data;    /* 存储元素的数组 */
    int Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;      /* 队列最大容量 */
};

BinTree Insert( BinTree BST, int X );     /* 插入 */
void LevelorderTraversal ( BinTree BT );  /* 层次遍历 */
Queue CreateQueue( );                /*  建队 */
bool IsFull( Queue Q );              /* 队满 */
bool IsEmpty( Queue Q );             /* 队空 */
bool AddQ( Queue Q, BinTree X );     /* 入队 */
BinTree DeleteQ( Queue Q );             /* 出队 */

int main()
{
    int N, i, X;   
    scanf("%d", &N);
    
    BinTree BST = NULL;
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    LevelorderTraversal(BST);
    return 0;
}

BinTree Insert( BinTree BST, int X )
{
    if(!BST)
    {  
        BST = (BinTree)malloc(sizeof(TreeNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    else
    {
        if(X > BST->Data)
            BST->Left = Insert(BST->Left,X);
        else if(BST->Data > X)
            BST->Right = Insert(BST->Right,X);
    }
    return BST; 
}

void LevelorderTraversal ( BinTree BT )
{ 
    Queue Q; 
    BinTree T;
    
    bool flag = true, ans = true;
    int order = 0; /* 顺序 */
    
    if ( !BT ) return; /* 若是空树则直接返回 */
    
    Q = CreateQueue(); /* 创建空队列Q */ 
    
    
    AddQ( Q, BT ); /* 树根入队 */
    BT->ID = 1;
    
    while ( !IsEmpty(Q) ) 
    {
        T = DeleteQ( Q ); /* 出队 */
        order++;
        
        if(T->ID != order)
            ans = false; /* 顺序不同 */
        if(flag)  /* 输出格式 */
        {
            printf("%d", T->Data);
            flag = false;
        }
        else printf(" %d", T->Data);
              
        if ( T->Left ){
            T->Left->ID = 2 * T->ID;  /* 左儿子顺序 */
            AddQ( Q, T->Left );       /* 左儿子入队 */
        }   
        if ( T->Right ){
            T->Right->ID = 2 * T->ID + 1;/* 右儿子顺序 */
            AddQ( Q, T->Right );         /* 右儿子入队 */
        }  
    }
    
    if(ans)  /* 顺序相同 */
        printf("\nYES");
    else
        printf("\nNO"); 
}

 /* 建队列 */
Queue CreateQueue( )//返回队列指针
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (BinTree*)malloc(MAXSIZE * sizeof(BinTree));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MAXSIZE;
    return Q;
}

/* 队满 */
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

/* 队空 */
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

/* 入队 */
bool AddQ( Queue Q, BinTree X )
{
    if ( IsFull(Q) ) {
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}

/* 出队 */
BinTree DeleteQ( Queue Q )
{    
    if ( IsEmpty(Q) )
        return NULL;
    Q->Front =(Q->Front+1)%Q->MaxSize;
    return  Q->Data[Q->Front];   
}