PAT甲级Invert a Binary Tree 柳神层序遍历的思路值得借鉴

1102 Invert a Binary Tree (25分)

The following is from Max Howell @twitter:

Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so fuck off.

Now it’s your turn to prove that YOU CAN invert a binary tree!
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 from 0 to N−1, 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 the first line the level-order, and then in the second line the in-order traversal sequences of the inverted tree. 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:

3 7 2 6 4 0 5 1
6 5 7 4 3 2 0 1

思路：就注意是翻转的二叉树，反转就是输入的左孩子，保存到右孩子的位置，就行了，然后层序 中序遍历就好啦。

#include <iostream>
#include <string>
using namespace std;
#include<vector>
#include<queue>

struct node
{

    int num;
    node *rchild,*lchild;
    node():rchild(NULL),lchild(NULL) {}//最初时候左右孩子节点指针都是NULL
};

vector<int> out2;
vector<int> out1;

void inOrder(node *root)//中序遍历
{
    if(root==NULL)
        return;
    inOrder(root->lchild);
    //cout<<root->num;
    out2.push_back(root->num);
    inOrder(root->rchild);
}

int main()
{
    int N;
    cin>>N;
    int info[N][2];
    for(int i=0; i<N; i++)//记录保存结点左右孩子的信息
    {
        char a,b;
        cin>>a>>b;
        if(a!='-')
        {
            info[i][0]=a-'0';
        }
        else
            info[i][0]=-1;
        if(b!='-')
        {
            info[i][1]=b-'0';
        }
        else
            info[i][1]=-1;
    }

    int sign[N]= {0}; //这样才能全部赋值为0  ,里面填1 就是sign[0]是1 其他为0，求那个事根节点
    node sn[N];//从新开辟了空间g++ 编译器 可支持这种写法，要不然就直接生成999个结点的数组也行
    for(int i=0; i<N; i++)//赋值每个孩子结点的左右指针，并顺便判断谁是根节点，没有父节点的就是了
    {
        sn[i].num=i;
        if(info[i][1]!=-1)//1存储的右孩子信息，但是使用lchild 左孩子指针指向，这就是翻转了
        {
            sn[i].lchild=&sn[info[i][1]];
            sign[info[i][1]]=-1;
        }
        if(info[i][0]!=-1)
        {
            sn[i].rchild=&sn[info[i][0]];
            sign[info[i][0]]=-1;
        }
    }
    int root;
    for(int i=0; i<N; i++)
        if(sign[i]==0)
            root=i;

    inOrder(&sn[root]);
    
    //下面是实现层序遍历
    vector<int> out1;

    queue<node*> que;
    que.push(&sn[root]);

    while(que.size()!=0)
    {
        queue<node*> get;
        while(!que.empty())
        {
            out1.push_back(que.front()->num);

            if(que.front()->lchild!=NULL)
                get.push(que.front()->lchild);
            if(que.front()->rchild!=NULL)
                get.push(que.front()->rchild);

            que.pop();
        }
        que=get;
    }

     //层序输出
    for(int i=0; i<out1.size(); i++)
    {
        if(i==0)
        cout<<out1[i];
        else
            cout<<' '<<out1[i];
    }
    //中序输出
       cout<<endl;
    for(int i=0; i<out2.size(); i++)
    {
        if(i==0)
        cout<<out2[i];
        else
            cout<<' '<<out2[i];
    }






    return 0;
}

我也看了看柳神的代码，感觉还是差距啊，50行搞定，层序遍历实现也很巧妙