【ACM】PAT. A1102 Invert a Binary Tree 【二叉树】

题目链接

题目分析

输入顺序即为结点下标，输入内容为结点的左右子树下标

解题思路

1、保存输入结点信息
2、找到根结点
3、构造出二叉树
4、不用再invert，遍历时反转顺序即可！

---

AC程序（C++）

/**************************
*@Author: 3stone
*@ACM: PAT.A1102 Invert a Binary Tree  
*@Time: 18/7/26
*@IDE: VSCode 2018 + clang
***************************/
#include<cstdio>
#include<queue>
#include<cstring>

using namespace std;

struct tree_key{
    int lkey, rkey;
}key[20];

struct Node {
    Node* lchild;
    Node* rchild;
    int data;
};

//构造二叉树
Node* create(int k) {

    //递归基  无左右子树
    if(k == -1) 
        return NULL;

    Node* root = new Node;
    root->data = k;

    root->lchild = create(key[k].lkey); 
    root->rchild = create(key[k].rkey);

    return root;
}//create

//中序遍历（左右子树反向）
void in_traversal(Node* root, int& n) {

    if(root == NULL) return; //递归结束

    in_traversal(root->rchild, n);

    n--;
    if(n == 0) printf("%d\n", root->data);
    else printf("%d ", root->data);

    in_traversal(root->lchild, n);

}//in-traversal

//层序遍历（左右子树反向）
void bfs_traversal(Node* root, int n) {

    queue<Node*> que;

    que.push(root);
    while(!que.empty()) {
        Node* p = que.front();
        n--;
        que.pop();
        if(n == 0) printf("%d\n", p->data);
        else printf("%d ", p->data);

        if(p->rchild) que.push(p->rchild);
        if(p->lchild) que.push(p->lchild);
    }

}//bfs-traversal

int main() {

    int n;
    char left, right;

    while(scanf("%d", &n) != EOF) {

        bool flag[20]; //标记结点是否出现
        int root_key;  //记录根节点下标
        memset(flag, false, sizeof(flag));
        for(int i = 0; i < 20; i++){
            key[i].lkey = -1;
            key[i].rkey = -1;
        }

        for(int i = 0; i < n; i++) {
            getchar(); //吸收换行符
            scanf("%c %c", &left, &right);
            //也可以这样吸收换行符：scanf("%*c%c %c", &left, &right);
            if(left != '-') {
                key[i].lkey = left - '0';
                flag[left-'0'] = true;
            }
            if(right != '-') {
                key[i].rkey = right - '0';
                flag[right-'0'] = true;
            }
        }

        //找到根节点下标
        for(int i = 0; i < n; i++){
            if(!flag[i])
                root_key = i;
        }

        //建树
        Node* root = create(root_key);

        //层序遍历
        bfs_traversal(root, n);

        //中序遍历
        in_traversal(root, n);

    }//while

    return 0;
}