03-树1. List Leaves (25)

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

typedef int ElementType;

struct TreeNode
{
    ElementType data;
    TreeNode* left;
    TreeNode* right;
};

TreeNode* CreateTreeNode()
{
    TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
    node->data = 0;
    node->left = NULL;
    node->right = NULL;
    return node;
}

typedef TreeNode* StackType;

struct LinkStack
{
    StackType data;
    LinkStack* next;
};

LinkStack* CreateStack()
{
    LinkStack *s;
    s = (LinkStack*) malloc( sizeof(struct LinkStack ));
    s->next = NULL;
    return s;
}

int IsEmpty( LinkStack *s )
{
    return ( s->next == NULL );
}

void Push(StackType item, LinkStack* s)
{
    LinkStack* newNode = (LinkStack*) malloc(sizeof(LinkStack));
    newNode->data = item;
    newNode->next = s->next;
    s->next = newNode;
}

StackType Pop(LinkStack* s)
{
    if (s->next == NULL)
    {
        printf("Stack is empty.");
        return NULL;
    }
    LinkStack* temp = s->next;
    s->next = temp->next;
    StackType k = temp->data;
    free(temp);
    return k;
}
typedef TreeNode* QueueType;

struct QNode
{
    QueueType data;
    QNode* next;
};
struct LinkQueue
{
    QNode* rear;
    QNode* front;
};

LinkQueue* CreateQueue()
{
    LinkQueue* queue = (LinkQueue*) malloc(sizeof(LinkQueue));
    queue->front = NULL;
    queue->rear = NULL;
    return queue;
}

void AddQ(LinkQueue* p, QueueType const item)
{
    if (p->front == NULL)
    {
        QNode* newNode = (QNode*) malloc(sizeof(QNode));
        newNode->data = item;
        newNode->next = NULL;
        p->front = newNode;
        p->rear = newNode;
        return;
    }
    QNode* newNode = (QNode*) malloc(sizeof(QNode));
    newNode->data = item;
    newNode->next = NULL;
    p->rear->next = newNode;
    p->rear = newNode;
}

QueueType DeleteQ(LinkQueue* p)
{
    if (p->front == NULL)
    {
        printf("Queue is empty.");
        return NULL;
    }
    QNode* temp = p->front;
    if (p->front == p->rear)
    {
        p->front = NULL;
        p->rear = NULL;
        QueueType item = temp->data;
        free(temp);
        return item;
    }
    p->front = p->front->next;
    QueueType item = temp->data;
    free(temp);
    return item;
}

bool IsEmptyQ(LinkQueue* queue)
{
    return (queue->front == NULL);
}


TreeNode* CreateBinTree(void)
{
    TreeNode* tree;
    LinkQueue* queue = CreateQueue();
    int tempData;
    printf("Please input head node: ");
    scanf("%d", &tempData);
    if (tempData)
    {
        tree = CreateTreeNode();
        tree->data = tempData;
        AddQ(queue, tree);
    }
    else
    {
        return NULL;
    }

    TreeNode* tempTree;
    while (!IsEmptyQ(queue))
    {
        tempTree = DeleteQ(queue);
        printf("Please input left node: ");
        scanf("%d", &tempData);
        if (!tempData)
        {
            tempTree->left = NULL;
        }
        else
        {
            tempTree->left = CreateTreeNode();
            tempTree->left->data = tempData;
            tempTree->left->left = NULL;
            tempTree->left->right = NULL;
            AddQ(queue, tempTree->left);
        }

        printf("Please input right node: ");
        scanf("%d", &tempData);
        if (!tempData)
        {
            tempTree->right = NULL;
        }
        else
        {
            tempTree->right = CreateTreeNode();
            tempTree->right->data = tempData;
            tempTree->right->left = NULL;
            tempTree->right->right = NULL;
            AddQ(queue, tempTree->right);
        }
    }
    return tree;
}

int FindLeaves(TreeNode* tree, int* output)
{
    LinkQueue *queue = CreateQueue();
    TreeNode* temp = CreateTreeNode();
    int n = 0;
    if (!tree)
    {
        return -1;
    }
    AddQ(queue, tree);
    while (queue->front != NULL)
    {
        temp = DeleteQ(queue);
        if (!temp->left && !temp->right)
        {
            *(output++) = temp->data;
            n++;
        }
        else
        {
            if (temp->left)
            {
                AddQ(queue, temp->left);
            }
            if (temp->right)
            {
                AddQ(queue, temp->right);
            }
        }
    }
    return n;
}

struct Branch
{
    int left;
    int right;
};

int main(void)
{
    int n = 0;
    scanf("%d", &n);
    Branch* nodeArray = (Branch*) malloc(sizeof(Branch) * n);
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
       if (!scanf("%d", &(nodeArray[i].left)))
       {
           nodeArray[i].left = 45;
       }
       if (!scanf("%d", &(nodeArray[i].right)))
       {
           nodeArray[i].right = 45;
       }

       if (nodeArray[i].left != 45)
       {
           sum += int(nodeArray[i].left);
       }
       if (nodeArray[i].right != 45)
       {
           sum += int(nodeArray[i].right);
       }
    }
    int head = ((n-1)*(n-1) + (n-1)) / 2 - sum;

    TreeNode* tree = CreateTreeNode();
    LinkQueue* queue = CreateQueue();
    int tempData;

    tree->data = head;
    AddQ(queue, tree);
    TreeNode* tempTree;
    while (!IsEmptyQ(queue))
    {
        tempTree = DeleteQ(queue);
        tempData = nodeArray[tempTree->data].left;
        if (tempData == 45)
        {
            tempTree->left = NULL;
        }
        else
        {
            tempTree->left = CreateTreeNode();
            tempTree->left->data = tempData;
            tempTree->left->left = NULL;
            tempTree->left->right = NULL;
            AddQ(queue, tempTree->left);
        }

        tempData = nodeArray[tempTree->data].right;
        if (tempData == 45)
        {
            tempTree->right = NULL;
        }
        else
        {
            tempTree->right = CreateTreeNode();
            tempTree->right->data = tempData;
            tempTree->right->left = NULL;
            tempTree->right->right = NULL;
            AddQ(queue, tempTree->right);
        }
    }
    int* output = (int*) malloc(sizeof(int) * n);
    int count = FindLeaves(tree, output);

    for (int i = 0; i < count; i++)
    {
        if (i < count - 1)
        {
            printf("%d ", output[i]);
        }
        else
        {
            printf("%d", output[i]);
        }
    }
    return 0;
}