03-树2 List Leaves

　　此题需要按要求输出叶节点，在输入序列中找到根节点构造好二叉树以及利用队列保存并按序输出叶节点是两大关键。

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10

typedef struct TreeNode *BinTree;
struct TreeNode{
    char Data;
    char LeftD;
    char RightD;
    BinTree Left;
    BinTree Right;
};

struct Node{
    BinTree BT;
    struct Node *Next;
};

struct QNode{
    struct Node *rear;
    struct Node *front;
};

typedef struct QNode *Queue;

BinTree BuildTree()
{
    BinTree T[MaxSize], t;
    t = T[0];
    T[0] = (BinTree)malloc(sizeof(struct TreeNode));
    int i, j, N, Root, a, b;
    char ln, rn;
     34     int checkRoot[MaxSize] = {2};
    scanf("%d
", &N);
    for(i = 0; i < N; i++)
        checkRoot[i] = 1;
    for(i = 0; i < N; i++){
        T[i] = (BinTree)malloc(sizeof(struct TreeNode));
        T[i]->Data = i + '0';
        scanf("%c %c
", &T[i]->LeftD, &T[i]->RightD);
        if(T[i]->LeftD == '-')
            T[i]->Left = NULL;
        else{
            a = T[i]->LeftD - '0';
            checkRoot[a] = 0;
        }
        if(T[i]->RightD == '-')
            T[i]->Right = NULL;
        else{
            b = T[i]->RightD - '0';
            checkRoot[b] = 0;
        }
    }
    for(i = 0; i < N; i++){
        ln = T[i]->LeftD;
        rn = T[i]->RightD;
        for(j = 0; j < N; j++){
            if(ln != '-' && ln == T[j]->Data)
                T[i]->Left = T[j];
            if(rn != '-' && rn == T[j]->Data)
                T[i]->Right = T[j];
        }
    }
    for(i = 0; i < N; i++){
        if(checkRoot[i] == 1)
            Root = i;
    }
    t = T[Root];
    return t;
}

Queue CreateQueue(int M)
{
    Queue PtrQ;
    PtrQ = (Queue)malloc(sizeof(struct QNode));
    PtrQ->front = (struct Node*)malloc(sizeof(struct Node));
    PtrQ->rear = PtrQ->front = NULL;
    return PtrQ;
}

int isEmpty(Queue PtrQ)
{
    return (PtrQ->front == NULL);
}

void AddQ(BinTree T, Queue PtrQ)
{
    struct Node *tmpCell;
    tmpCell = (struct Node*)malloc(sizeof(struct Node));
    tmpCell->BT = T;
    tmpCell->Next = NULL;
    if(PtrQ->front == NULL){
        PtrQ->front = tmpCell;
        PtrQ->rear = tmpCell;
    }else{
        PtrQ->rear->Next = tmpCell;
        PtrQ->rear = tmpCell;
    }
}

BinTree DeleteQ(Queue PtrQ)
{
    struct Node *FrontCell;
    BinTree FrontElem;
    if(PtrQ->front == NULL)
        return NULL;
    FrontCell = PtrQ->front;
    if(PtrQ->front == PtrQ->rear)
        PtrQ->front = PtrQ->rear = NULL;
    else
        PtrQ->front = PtrQ->front->Next;
    FrontElem = FrontCell->BT;
    free(FrontCell);
    return FrontElem;
}

void PrintLeaves(BinTree BT)
{
    Queue Q;
    BinTree t;
    int LeaveDatas[MaxSize], i = 0, j;
    if(!BT)
        return;
    Q = CreateQueue(MaxSize);
    AddQ(BT, Q);
    while(!isEmpty(Q)){
        t = DeleteQ(Q);
        if(t->Left == NULL && t->Right == NULL){
            LeaveDatas[i] = t->Data - '0';
            i++;
        }
        if(t->Left)
            AddQ(t->Left, Q);
        if(t->Right)
            AddQ(t->Right, Q);
    }
    printf("%d", LeaveDatas[0]);
    for(j = 1; j < i; j++)
        printf(" %d", LeaveDatas[j]);
}

int main(int argc, char const *argv[])
{
    BinTree BT;
    BT = BuildTree();
    PrintLeaves(BT);
    return 0;
}

　　其中，找根节点是用节点标记的方式，一开始将每个节点标记位都记为1，在构造过程中，若这个节点成为了别的节点的子节点，则标记位置0。最后看哪个节点没有成为任何其它节点的子节点，是为根节点。判断时需注意字符型和整型的转换。

　　构造好树之后按要求遍历，过程中注意将叶节点放入队列，最后按序输出即可。