完全二叉树判定（C语言）

输入样例：
124005003600700
1240050036000
1240050030600
1246000500300
120034000
0

输出样例：
YES
YES
NO
NO
NO

#include 
#include 
#include 

#define MAX_SIZE 100
#define ElemType BiTree

typedef struct BiTNode {
    char data;
    struct BiTNode *left, *right;
} BiTNode, *BiTree;

typedef struct SqQueue {
    ElemType data[MAX_SIZE];
    int front, rear;
} SqQueue;


/*Binary Tree Part*/
void CreateBiTree(BiTree *T, char *str, int *cursor);

void DestroyBiTree(BiTree T);

bool IsCompleteBinaryTree(BiTree T);

bool IsCompleteBinaryTree_(BiTree T);

/*Sequence Queue Part*/
void InitQueue(SqQueue *Q);

bool IsEmptyQueue(SqQueue Q);

void EnQueue(SqQueue *Q, ElemType e);

void DeQueue(SqQueue *Q, ElemType *e);

int main() {
    char str[MAX_SIZE];
    while (scanf("%s", str) && str[0] != 48) {
        BiTree T = NULL;
        int cursor = 0;

        CreateBiTree(&T, str, &cursor);
        printf("\n");
        /*printf("%s", (IsCompleteBinaryTree(T) ? "YES" : "NO"));*/
        printf("%s", (IsCompleteBinaryTree_(T) ? "YES" : "NO"));
        DestroyBiTree(T);
    }

    return 0;
}

void CreateBiTree(BiTree *T, char *str, int *cursor) {
    if (str[*cursor] == 48) {
        *T = NULL;
    } else {
        *T = (BiTree) malloc(sizeof(BiTNode));
        (*T)->data = str[*cursor];

        (*cursor)++;
        CreateBiTree(&((*T)->left), str, cursor);
        (*cursor)++;
        CreateBiTree(&((*T)->right), str, cursor);
    }
}

void DestroyBiTree(BiTree T) {
    if (T) {
        DestroyBiTree(T->left);
        DestroyBiTree(T->right);
        free(T);
    }
}

bool IsCompleteBinaryTree_(BiTree T) {
    SqQueue Q;
    InitQueue(&Q);
    BiTree now_node = NULL;
    int not_appear = 0;//child nodes must not appear

    EnQueue(&Q, T);
    while (!IsEmptyQueue(Q)) {
        DeQueue(&Q, &now_node);
        if (not_appear == 1 && (now_node->left || now_node->right)) return false;
        if (!now_node->left && now_node->right) {//null && not null
            return false;
        } else if (now_node->left && now_node->right) {//not null && not null
            EnQueue(&Q, now_node->left);
            EnQueue(&Q, now_node->right);
        } else {//others
            not_appear = 1;
        }
    }
    return true;
}

bool IsComplete(BiTree T) {
    SqQueue Q;
    BiTNode *node = NULL;

    if (!T) return false;
    InitQueue(&Q);
    EnQueue(&Q, T);
    while (!IsEmptyQueue(Q)) {
        DeQueue(&Q, &node);
        if (node) {
            /*空结点也入队*/
            EnQueue(&Q, node->left);
            EnQueue(&Q, node->right);
        } else {
            while (!IsEmptyQueue(Q)) {
                DeQueue(&Q, &node);
                if (node) return false;
            }
        }
    }
    return true;
}

void InitQueue(SqQueue *Q) {
    Q->front = Q->rear = 0;
}

bool IsEmptyQueue(SqQueue Q) {
    return (Q.front == Q.rear) ? true : false;
}

void EnQueue(SqQueue *Q, ElemType e) {
    if ((Q->rear + 1) % MAX_SIZE == Q->front) {
        printf("full\n");
        return;
    }
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAX_SIZE;
}

void DeQueue(SqQueue *Q, ElemType *e) {
    if (Q->rear == Q->front) {
        printf("empty\n");
        return;
    }
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAX_SIZE;
}