1102 Invert a Binary Tree 甲级 xp_xht123

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

解题思路：因为数据范围很小，所以存数据时先用char读入判断是否为  '-' 如果是则将这个点赋值为-1，反之减去0字符即可

注意：题目为反转二叉树，无需遍历的时候以右向左的顺序遍历，只需存入二叉树的时候将左右节点反着存即可

根节点就是输入中没有给出的节点就是根节点，寻找根节点的时候可以使用map映射一下即可

最后，两个遍历，层序遍历使用bfs，中序遍历使用dfs即可

以下是代码：

bfs

void bfs(int u)
{
    queue<int>q;
    q.push(u);
    vector<int>res;
    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        res.push_back(t);
        if(a[t].left != -1) q.push(a[t].left);
        if(a[t].right != -1) q.push(a[t].right);
    }
    for(int i = 0;i < res.size();i ++)
    {
        if(i) cout<<" ";
        cout<<res[i];
    }
    puts("");
}

dfs

bool flag = true;
void dfs(int u)
{
    if(u == -1) return ;
    dfs(a[u].left);
    //中序遍历输出就在中间
    if(flag)
    {
        cout<<u;
        flag = false;
    }
    else cout<<" "<<u;
    dfs(a[u].right);
}

完整代码：

#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>

using namespace std;
const int N = 20;

struct Node
{
    int left;
    int right;
}a[N];
int n;

void bfs(int u)
{
    queue<int>q;
    q.push(u);
    vector<int>res;
    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        res.push_back(t);
        if(a[t].left != -1) q.push(a[t].left);
        if(a[t].right != -1) q.push(a[t].right);
    }
    for(int i = 0;i < res.size();i ++)
    {
        if(i) cout<<" ";
        cout<<res[i];
    }
    puts("");
}

bool flag = true;
void dfs(int u)
{
    if(u == -1) return ;
    dfs(a[u].left);
    //中序遍历输出就在中间
    if(flag)
    {
        cout<<u;
        flag = false;
    }
    else cout<<" "<<u;
    dfs(a[u].right);
}

int main()
{
    cin>>n;
    map<int,int>mp;
    for(int i = 0;i < n;i ++) mp[i] = 0;
    for(int i = 0;i < n;i ++)
    {//存储方式与原来的二叉树相反即可
        char x , y;
        cin>>x>>y;
        if(x == '-') a[i].right = -1;
        else 
        {
            a[i].right = x - '0';
            mp[a[i].right] = 1;
        }
        
        if(y == '-') a[i].left = -1;
        else 
        {
            a[i].left = y - '0';
            mp[a[i].left] = 1;
        }
    }
    
    int root = -1;
    for(auto i:mp)
    {
        if(!i.second) 
        {
            root = i.first;
            break;
        }
    }
    bfs(root);
    dfs(root);
    return 0;
}