List Leaves

List Leaves

Given a tree, you are supposed to list all the leaves in the order of top down, and left to right.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤10) which is the total number of nodes in the tree -- and hence the nodes are numbered from 0 to N−1. Then N lines follow, each corresponds to a node, and gives the indices of the left and right children of the node. If the child does not exist, a "-" will be put at the position. Any pair of children are separated by a space.

Output Specification:

For each test case, print in one line all the leaves' indices in the order of top down, and left to right. There must be exactly one space between any adjacent numbers, and no extra space at the end of the line.

Sample Input:

8
1 -
- -
0 -
2 7
- -
- -
5 -
4 6

Sample Output:

4 1 5

 

解题思路

　　这道题目算是比较基础的。树是存储到静态链表中的，而且只存储左右孩子的下标，没有存储根节点的下标。关键的地方就在于如何找到根节点的下标位置？

　　我们知道，整一颗树的根节点是不可能成为其他节点的孩子节点的。这意味着，在静态链表中所存储的左右孩子的下标是不包括根节点的下标的。所以我们们可以把整个静态链表遍历一遍，找到没有出现过的下标位置，那么这个下标就对应着根节点的下标。

　　找到了根节点的下标位置后，剩下的只需要用一个队列来层次遍历就可以实现从上到下，左到右的顺序来输出叶子节点了。

　　我用了两种代码，其实本质是一样的。只不过第一次是自己用类来创建一个很简陋的队列。

　　AC代码如下：

#include <cstdio>

struct TNode {
    int left;
    int right;
}T[10];

class Queue {
public:
    int *data;
    int front;
    int rear;
    
public:
    Queue() {
        this -> data = new int[10];
        this -> front = this -> rear = 0;
    }
    void enQueue(int root) {
        this -> data[this -> rear++] = root;
    }
    int deQueue() {
        return this -> data[this -> front++];
    }
    bool isEmpty() {
        return this -> front == this -> rear;
    }
    ~Queue() {
        if (data) {
            delete data;
            data = NULL;
        }
    }
};

int creatTree();
void leveleTraversal(int root);

int main() {
    int root = creatTree();
    leveleTraversal(root);
    
    return 0;
}

int creatTree() {
    int n;
    scanf("%d", &n);
    
    char ch1, ch2;
    bool isFind[n] = {false};
    for (int i = 0; i < n; i++) {
        scanf("\n%c %c", &ch1, &ch2);
        
        if (ch1 == '-') T[i].left = -1;
        else {
            T[i].left = ch1 - '0';
            isFind[T[i].left] = true;
        }
        
        if (ch2 == '-') T[i].right = -1;
        else {
            T[i].right = ch2 - '0';
            isFind[T[i].right] = true;
        }
    }
    
    int index = 0;
    while (index < n && isFind[index]) {
        index++;
    }
    
    return index;
}

void leveleTraversal(int root) {
    Queue Q;
    Q.enQueue(root);
    
    bool flag = false;
    while (!Q.isEmpty()) {
        int r = Q.deQueue();
        
        if (T[r].left == -1 && T[r].right == -1) {
            if (flag) putchar(' ');
            printf("%d", r);
            flag = true;
        }
        
        if (T[r].left != -1) Q.enQueue(T[r].left);
        if (T[r].right != -1) Q.enQueue(T[r].right);
    }
}

　　第二份代码用了STL中的queue，使用起来方便多了。

#include <cstdio>
#include <queue>

struct TNode {
    int left;
    int right;
}T[10];

int creatTree();
void leveleTraversal(int root);

int main() {
    int root = creatTree();
    leveleTraversal(root);
    
    return 0;
}

int creatTree() {
    int n;
    scanf("%d", &n);
    
    char ch1, ch2;
    bool isFind[n] = {false};
    for (int i = 0; i < n; i++) {
        scanf("\n%c %c", &ch1, &ch2);
        
        if (ch1 == '-') T[i].left = -1;
        else {
            T[i].left = ch1 - '0';
            isFind[T[i].left] = true;
        }
        
        if (ch2 == '-') T[i].right = -1;
        else {
            T[i].right = ch2 - '0';
            isFind[T[i].right] = true;
        }
    }
    
    int index = 0;
    while (index < n && isFind[index]) {
        index++;
    }
    
    return index;
}

void leveleTraversal(int root) {
    std::queue<int> Q;
    Q.push(root);
    
    bool flag = false;
    while (!Q.empty()) {
        int r = Q.front();
        Q.pop();
        
        if (T[r].left == -1 && T[r].right == -1) {
            if (flag) putchar(' ');
            printf("%d", r);
            flag = true;
        }
        
        if (T[r].left != -1) Q.push(T[r].left);
        if (T[r].right != -1) Q.push(T[r].right);
    }
}