树（多叉树）的建立、遍历、翻转

昨天帮朋友做网易的笔试题（吐槽一下网易的题目有点变态），遇到了一道翻转树的题，于是抽空做了一下。

翻转树的结构，如果在层序遍历时将孩子数组翻转输出并没有改变树的结构，当然你可以先这样输出再建树，这样做会比较麻烦，正确的做法是需要递归翻转每个孩子数组。

void MTree::init(MNode *root) { 
    this->root = root; 
}

MNode* MTree::getNode() { 
    return root; 
}

void MTree::putChild(MNode *node, MNode *parent) {
    parent->children.push_back(node);
    node->Parent = parent;
}
// 先序建树，特点就是父节点都是出现过的，孩子节点都是未出现过的
MTree MTree::construct_tree(vector<vector<int>> root){
    MTree tree;
    if(root.empty()){
        cout << "empty" << endl;
        return tree;
    } 
    MNode* node = new MNode;
    node->element = root[0][0];
    node->Parent = nullptr;
    tree.init(node);
    mp[root[0][0]] = node;
    for(int i = 1; i < root.size(); i++){   
        MNode* node = new MNode;
        node->element = root[i][0];
        mp[root[i][0]] = node;
        tree.putChild(node, mp[root[i][1]]);
    }
    return tree;
}
// 先序遍历
void MTree::pre_tranversal() {
    this->pre_tranversal(this->root);
}

void MTree::pre_tranversal(MNode *root) {
    vector<MNode*> nodes = root->children;
    if(root->Parent == nullptr){
        pre_order.push_back({root->element, 0});
        cout << root->element << "," ;
    }
    else{
        pre_order.push_back({root->element, root->Parent->element});
        cout << root->element << "," ;
    }
    for (int i = 0; i < nodes.size(); i++) {
        if (nodes[i]->children.size() > 0)
            pre_tranversal(nodes[i]);
        else{
            cout << nodes[i]->element << "," ;
            pre_order.push_back({nodes[i]->element, nodes[i]->Parent->element});
        }     
    }  
}
//核心算法
MNode* MTree::invertTree(MNode *root) {
    if(root)    reverse(root->children.begin(), root->children.end());
    else return NULL;
    for(int i = 0; i < root->children.size(); i++){
        invertTree(root->children[i]);
    }
    return root;
}

vector<vector<int>> MTree::reverse_node(vector<vector<int>> order){
    MTree tree;
    tree = tree.construct_tree(order);
    MNode* root = tree.getNode();        //得到根节点
    invertTree(root);
    tree.pre_order = {{}};
    tree.pre_tranversal();
    return  tree.pre_order;
}

完整的测试代码如下，欢迎大家前来优化，可能有部分bug也没时间去调试：

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
using namespace std;
typedef struct MNode {
    int element;
    vector<MNode*> children;
    MNode *Parent;
} MNode;

class MTree {
private:
    MNode *root;
public:
    vector<vector<int>> pre_order;
    vector<vector<int>> post_order;
    vector<vector<int>> level_order;
    map<int, MNode*> mp;
    void init(MNode *root);
    MNode* getNode();
    void putChild(MNode* node, MNode* parent);
    MTree construct_tree(vector<vector<int>> root);
    void pre_tranversal();
    void pre_tranversal(MNode *root);
    void level_tranversal();
    void level_tranversal(MNode *root);
    MNode* invertTree(MNode *root);
    vector<vector<int>> reverse_node(vector<vector<int>> root);
    void post_tranversal();
    void post_tranversal(MNode *root);
    int getMaxDepth(MNode *root, vector<MNode*> nodes);
};

void MTree::init(MNode *root) { 
    this->root = root; 
}

MNode* MTree::getNode() { 
    return root; 
}

void MTree::putChild(MNode *node, MNode *parent) {
    parent->children.push_back(node);
    node->Parent = parent;
}
// 先序建树，特点就是父节点都是出现过的，孩子节点都是未出现过的
MTree MTree::construct_tree(vector<vector<int>> root){
    MTree tree;
    if(root.empty()){
        cout << "empty" << endl;
        return tree;
    } 
    MNode* node = new MNode;
    node->element = root[0][0];
    node->Parent = nullptr;
    tree.init(node);
    mp[root[0][0]] = node;
    for(int i = 1; i < root.size(); i++){   
        MNode* node = new MNode;
        node->element = root[i][0];
        mp[root[i][0]] = node;
        tree.putChild(node, mp[root[i][1]]);
    }
    return tree;
}
// 非先序建树,需要考虑父子节点有没有出现过的情况
// MTree MTree::construct_tree(vector<vector<int>> root){
//     MTree tree;
//     if(root.empty()){
//         cout << "empty" << endl;
//         return tree;
//     } 
//     for(int i = 0; i < root.size(); i++){
//         if(root[i][1] == 0){ //先找到根节点
//             MNode* node = new MNode;
//             node->element = root[i][0];
//             node->Parent = nullptr;
//             tree.init(node);
//             mp[root[i][0]] = node;
//         }
//     } 
//     for(int i = 0; i < root.size(); i++){   
//         if(root[i][1] != 0){
//             if(mp.find(root[i][0]) == mp.end() && mp.find(root[i][1]) != mp.end()){
//                 // 孩子节点没出现
//                 MNode* node = new MNode;
//                 node->element = root[i][0];
//                 mp[root[i][0]] = node;
//                 tree.putChild(node, mp[root[i][1]]);
//             }
//             else if(mp.find(root[i][0]) == mp.end() && mp.find(root[i][1]) == mp.end()){
//                 // 父子节点均未出现
//                 MNode* node1 = new MNode;
//                 MNode* node2 = new MNode;
//                 node1->element = root[i][0];
//                 node2->element = root[i][1];
//                 mp[root[i][0]] = node1;
//                 mp[root[i][1]] = node2;
//                 tree.putChild(mp[root[i][0]], mp[root[i][1]]);
//             }
//             else if(mp.find(root[i][0]) != mp.end() && mp.find(root[i][1]) != mp.end()){
//                 // 父子节点均出现过
//                 tree.putChild(mp[root[i][0]], mp[root[i][1]]);
//             }
//         }
//     }
//     return tree;
// }
MNode* MTree::invertTree(MNode *root) {
    if(root)    reverse(root->children.begin(), root->children.end());
    else return NULL;
    for(int i = 0; i < root->children.size(); i++){
        invertTree(root->children[i]);
    }
    return root;
}

vector<vector<int>> MTree::reverse_node(vector<vector<int>> order){
    MTree tree;
    tree = tree.construct_tree(order);
    MNode* root = tree.getNode();        //得到根节点
    invertTree(root);
    tree.pre_order = {{}};
    tree.pre_tranversal();
    return  tree.pre_order;
}
// 先序遍历
void MTree::pre_tranversal() {
    this->pre_tranversal(this->root);
}

void MTree::pre_tranversal(MNode *root) {
    vector<MNode*> nodes = root->children;
    if(root->Parent == nullptr){
        pre_order.push_back({root->element, 0});
        cout << root->element << "," ;
    }
    else{
        pre_order.push_back({root->element, root->Parent->element});
        cout << root->element << "," ;
    }
    for (int i = 0; i < nodes.size(); i++) {
        if (nodes[i]->children.size() > 0)
            pre_tranversal(nodes[i]);
        else{
            cout << nodes[i]->element << "," ;
            pre_order.push_back({nodes[i]->element, nodes[i]->Parent->element});
        }     
    }  
}
// 层次遍历
void MTree::level_tranversal() {
    this->level_tranversal(this->root);
}

void MTree::level_tranversal(MNode *root) {
    if(root == nullptr) return;
    vector<MNode*> nodes = root->children;
    queue<vector<MNode*>> q;
    vector<MNode*> tmp;
    q.push({root});
    while(!q.empty()){
        tmp = q.front();
        for(int i = 0; i < tmp.size(); i++){
            if(!(tmp[i]->children).empty()){
                // reverse((tmp[i]->children).begin(), (tmp[i]->children).end());
                q.push(tmp[i]->children);
            }      
        }
        for(int i = 0; i < q.front().size(); i++){
            if(q.front()[i]->Parent == nullptr){        //根节点处理
                level_order.push_back({q.front()[i]->element, 0});
                cout << q.front()[i]->element << ",";
            }                 
                
            else{
                level_order.push_back({q.front()[i]->element, q.front()[i]->Parent->element});
                cout << q.front()[i]->element << ",";
            }
        }
        q.pop();
    }
}

// 后续遍历
void MTree::post_tranversal() {
    this->post_tranversal(this->root);
}

void MTree::post_tranversal(MNode *root) {
    vector<MNode*> nodes = root->children;
    for (int i = 0; i < nodes.size(); i++) {
        if (nodes[i]->children.size() > 0)
            post_tranversal(nodes[i]);
        else{
            cout << nodes[i]->element << "," ;
            post_order.push_back({nodes[i]->element, nodes[i]->Parent->element});
        }     
    }
    if(root->Parent == nullptr){
        post_order.push_back({root->element, 0});
        cout << root->element << "," ;
    }
    else{
        post_order.push_back({root->element, root->Parent->element});
        cout << root->element << "," ;
    }
}

int MTree::getMaxDepth(MNode *root,vector<MNode*> nodes) {
    auto iResult = 0;
    return iResult;
}

int main(){
    // vector<vector<int>> root = {{5,2},{1,0},{2,1},{6,5},{3,1},{7,5},{4,1}};
    vector<vector<int>> root = {{1,0},{2,1},{5,2},{6,5},{3,1},{7,5},{4,1}};
    MTree tree;
    tree = tree.construct_tree(root);
    tree.pre_tranversal();
    cout << endl << "pre order"<< endl;
    // 打印树的先序遍历数组
    for (auto it = tree.pre_order.begin(); it != tree.pre_order.end() ; it++) {
        for (int i = 0; i < (*it).size(); i++) 
            cout << (*it)[i] << " " ;
        cout << endl; 
    }  
    tree.post_tranversal();
    cout << endl << "post order"<< endl;
    // 打印树的后序遍历数组
    for (auto it = tree.post_order.begin(); it != tree.post_order.end() ; it++) {
        for (int i = 0; i < (*it).size(); i++) 
            cout << (*it)[i] << " " ;
        cout << endl; 
    }
    // 打印树的层次遍历数组
    tree.level_tranversal();
    cout << endl << "level order"<< endl;
    for (auto it = tree.level_order.begin(); it != tree.level_order.end() ; it++) {
        for (int i = 0; i < (*it).size(); i++) 
            cout << (*it)[i] << " " ;
        cout << endl; 
    }
    cout << "reverse" << endl;
    vector<vector<int>> res = tree.reverse_node(root);
    for (auto it = res.begin(); it != res.end() ; it++) {
        for (int i = 0; i < (*it).size(); i++) 
            cout << (*it)[i] << " " ;
        cout << endl; 
    } 
}