03-树2 List Leaves (队列——链式存储)

　　这道题目需要按要求由上至下、从左到右 输出 叶节点(层序遍历) 。根据输入的数据构建好二叉树并返回根节点， 再利用队列的插入和删除层序遍历二叉树，同时将叶节点以链式结构进行存储， 最后以链表的形式输出。

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

#define null -1
#define MaxTreeNode 10

typedef int ElementType;
typedef int Tree;
typedef struct TreeNode *BinTree;
struct TreeNode {
    ElementType Data;
    Tree left;
    Tree right;
    BinTree Left;
    BinTree Right;
};

struct Node {    // 队列中的节点 
    BinTree BT;
    struct Node *Next;
};
typedef struct Node *Position;

struct QNode {
    Position Front, Rear;    // 队列的头、尾指针 
};
typedef struct QNode *Queue;

typedef struct node *PtrToNode;
struct node {
    int value;
    PtrToNode next;
};
typedef PtrToNode List;

BinTree BulidTree(int N);
Queue CreateQueue();
int IsEmpty(Queue Q);
void AddQ(Queue Q, BinTree BT);
BinTree DeleteQ(Queue Q);
List FindLeaf(BinTree BT);
void Print(List L);

int main()
{
    int N;        // 节点数量
    scanf("%d
", &N);
    
    BinTree RootNode;
    RootNode = BulidTree(N);
    
    List L;
    L = FindLeaf(RootNode);

    Print(L);
    
    return 0;
}

Queue CreateQueue()
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Front = Q->Rear = NULL;
    
    return Q;
}

int IsEmpty(Queue Q)
{
    return ( Q->Front == NULL );
}

void AddQ(Queue Q, BinTree BT)
{
    struct Node *TmpCell = (struct Node*)malloc(sizeof(struct Node)); 
    TmpCell->Next = NULL;
    TmpCell->BT = BT;
    
    if ( IsEmpty(Q) )    //     队列为空 
        Q->Front = Q->Rear = TmpCell;
    else {
        Q->Rear->Next = TmpCell;
        Q->Rear = TmpCell;
    }
}

BinTree DeleteQ(Queue Q)
{
    if ( IsEmpty(Q) )    return NULL;
    
    struct Node *FrontCell;
    BinTree FrontElem;
    FrontCell = Q->Front;
    
    if ( Q->Front == Q->Rear )        //  若队列中只有一个元素 
        Q->Front = Q->Rear = NULL;    //  删除后置空 
    else                         
        Q->Front = Q->Front->Next;
    
    FrontElem = FrontCell->BT;
    free(FrontCell);
    
    return FrontElem;
}

List FindLeaf(BinTree BT)
{
    if ( !BT )        return NULL;
    
    List r, p, t;
    p = (List)malloc(sizeof(struct node));    p->next = NULL;    
    r = p;
    
    Queue Q;
    Q = CreateQueue();    // 创建空队列
    AddQ(Q, BT);
    
    BinTree T;
    while ( !IsEmpty(Q) ) {
        T = DeleteQ(Q);
        if ( T->Left == NULL && T->Right == NULL ) {
            t = (List)malloc(sizeof(struct node));    t->next = NULL;    
            t->value = T->Data;
            r->next = t; r = t;
        } else {
            if ( T->Left )    AddQ(Q, T->Left);
            if ( T->Right )   AddQ(Q, T->Right);
        }
    }
    t = p; p = p->next; free(t);
    
    return p;
}

void Print(List L)
{
    if ( !L )    return;
    int flag = 1;　　　　 
    
    while ( L ) {
        if ( flag )
            flag = 0;
        else
            printf(" ");
        printf("%d", L->value);
        
        L = L->next;
    }
}

BinTree BulidTree(int N)
{
    BinTree T[N];
    Tree Root;
    int check[N];
    char cl, cr;
    int i, j;
    if ( N ) {
        for ( i = 0; i < N; i++ )    check[i] = 0;
        for ( i = 0; i < N; i++ ) {
            scanf("%c %c
", &cl, &cr);
            T[i] = (BinTree)malloc(sizeof(struct TreeNode));
            T[i]->Data = i;
            // left
            if ( cl != '-' ) {
                T[i]->left = cl - '0';
                check[T[i]->left] = 1;
            } else {
                T[i]->left = null;
            }
            // right
            if ( cr != '-' ) {
                T[i]->right = cr - '0';
                check[T[i]->right] = 1;
            } else {
                T[i]->right = null;
            }
        }
        // 构建二叉树
        Tree L, R;
        for ( i = 0; i < N; i++ ) {
            L = T[i]->left;
            R = T[i]->right;
            
            if ( L != null )    T[i]->Left = T[L];
            else                 T[i]->Left = NULL;
            
            if ( R != null )    T[i]->Right = T[R];
            else                T[i]->Right = NULL;
        }
        // 找到根节点所在位置 
        for ( i = 0; i < N; i++ )
            if ( !check[i] )    break;
        Root = i;
        
    } else {
        return NULL;
    }
    
    return T[Root];
}

　　在这道题目中，相比顺序存储，链式存储应该更为清晰直观。