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

最新推荐文章于 2023-06-07 12:11:52 发布
原创 最新推荐文章于 2023-06-07 12:11:52 发布 · 783 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种翻转树结构的算法实现，通过递归方式翻转树的子节点，实现了树结构的翻转。文章提供了详细的代码示例，包括树的构建、遍历和翻转过程。

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

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

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; 
    } 
}

 

alpaca_ll
关注
Algorithm：【算法进阶之路】之算法面试刷题集合—树结构算法的简介(二叉树/多路查找树/字典树)、具体结构(FBT/CBT/BST/BBT/Heap/Huffman、B树/B+树/R树、字典树)
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
08-02 1万+
​ Algorithm：【算法进阶之路】之算法面试刷题集合—树结构算法的简介(二叉树/多路查找树/字典树)、具体结构(FBT/CBT/BST/BBT/Heap/Huffman、B树/B+树/R树、字典树)及其运算(增删查/遍历/旋转)、代码实现之详细攻略 目录 一、树结构 1.1、二叉树的简介 1.2、多路查找树(特殊的多叉树)——二叉到多叉的思考 1.3、字典树(Trie) 二、二叉树相关的算法题集合 早期—二叉
手撕红黑树——C++高阶数据结构详解
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
多叉树的建立（非常重要）
03-10 2119
多叉树的建立是以前没有遇到过的 可以有这样的一个数据结果 一个结构体：里面保存一些这个节点的信息，以及定义一个vector，vector里面是孩子的信息，既可以是数组实现的动态分配的节点编号，也可以直接在里面装容器。 注意：在函数里面如果要使用一个结构体的话，必须要加&符号！！！ 还有一点，如果要想对某一些特殊的元素做比较的话，最好不要使用cmp，而直接使用结构体中...
算法实战——多叉树全路径遍历
weixin_34227447的博客
05-28 1429
本文为原创作品，首发于微信公众号：【坂本先生】，如需转载请在文首明显位置标明“转载于微信公众号：【坂本先生】”，否则追究其法律责任。 微信文章地址：实战算法——多叉树全路径遍历 前言 本文研究的是如何对一个多叉树进行全路径的遍历，并输出全路径结果。该问题的研究可以用在：Trie树中查看所有字典值这个问题上。本文将对该问题进行详细的模拟及进行代码实现，讨论了递归和非递归两种方法优劣并分别进行实现，如...
高级数据结构及算法：树的遍历
凯凯在此
07-28 1096
文章目录1. 多叉树遍历1.1 深度优先遍历先序遍历后序遍历1.2 广度优先遍历2. 二叉树遍历2.1 深度优先遍历先序遍历后序遍历中序遍历 1. 多叉树遍历 图形演示 1.1 深度优先遍历 深度优先遍历：从根节点开始先沿着树的一个枝遍历到叶子节点，再遍历其他的枝。深度优先遍历又分为先序遍历和后序遍历 先序遍历 上图树的先序遍历结果：A → B → D → G → H → I → C → E → J → F 递归深度优先遍历：先序遍历 以 力扣589题：叉树的前序遍历 为例 /* // Definitio
多叉树的设计、建立、层次优先遍历和深度优先遍历
09-22
现了一个多叉树建立函数，建立函数根据用户的输入，首先建立一个新的节点，然后根据B的值进行深度递归调用。用户输入节点的顺序就是按照深度递归的顺序。另外，我们实现了一个层次优先遍历函数。该函数用一个队列实现该多叉树的层次优先遍历。首先将根节点入队列，然后检测队列是否为空，如果不为空，将队列出队列，访问出队列的节点，然后将该节点的子节点指针入队列，依次循环下去，直至队列为空，终止循环，从而完成整个多叉树的层次优先遍历。
多叉树的构建
dongyu_1989的博客
03-08 3988
实现一棵多叉树这棵树可以有任意多颗子树 0-n    1 2  3  45 6 7  8输入建立二叉树，输入的格式是每个节点的具体数据和拥有的孩子数目例如上面的树是这样建成的：1 32 25 06 03 17 04 1 1 #include &lt;iostream&gt; 2 #include &lt;vector&gt; 3 #include &lt;queue&gt; 4 using nam...
二叉排序树、AVL树、红黑树、B树、B+树、Hash树、
qq_36222714的博客
03-05 1558
二叉排序树 1.基本应用 二叉排序树也称为也叫二叉查找树，二叉搜索树， BST。 满足二叉查找树的一般性质,是指一棵空树具有如下性质: 对于二叉树中的任何一个非叶子节点，要求左子节点比当前节点值小，右子节点比当前节点值大。 任意节点的左右子树也分别是二叉查找树. 没有键值相等的节点. 中序遍历二叉排序树得到递增有序序列 2. 局限性及应用 一个二叉排序树是由n个节点随机构成,所以，对于某些情况,二...
斩获 offer 的 Java 面试宝典
热门推荐
程序员爱酸奶
04-11 1万+
这是本人整理的数万字的面试笔记，基本上涵盖了 Java 领域的所有技术栈，本人也是凭借这份面试笔记斩获了近 10 个 offer，面试成功率高达80%。当然这份笔记是我根据自身的经验和技术栈整理的，自己觉得很重要的或者记不清的就会记录记录下来，面试被问到的时候也有回答的思路。现在共享给大家，希望对准备面试的小伙伴有帮助。 1. 微服务 1.1 主流注册中心对比 zookeeper：zookeeper 作为注册中心主要是因为它具有节点变更通知功能。只要客户端监听相关服务节点，服务节点有所变更就能及时的通知到监
字节跳动3月面试遇到的高频算法题
Erazer_Control
05-01 1643
本文汇总了牛客2021.3.1~2021.3.30 两个月的牛客面经考到的Leetcode题目 最终的高频题榜单数据可以在CodeTop题库（https://codetop.cc）查询，支持按部门、岗位分类筛选。 CodeTop已包括字节跳动、腾讯、美团、快手等十余家公司，覆盖100多个部门。 字节跳动 数据研发 https://www.nowcoder.com/discuss/602031 2021.03.01 有100个方格，每个上面有毒蘑菇和体力蘑菇，毒蘑菇减体力体力
家谱图-多叉树-c语言-数据结构
04-24
本程序主要介绍使用c语言的树数据结构，比较全面的介绍和使用多叉树。
多叉树构建和排序
离离原上草，一岁一枯荣，野火烧不尽，春风吹又生。
11-03 669
多叉树构建和排序，多叉树是最原始的树型数据结构，二叉树和红黑树都是基于此开发而来。 该树主要是功能分为数据挂载和数据查找。
多叉树的构建，条件查询，修改删除节点
谁说自己不可以
06-07 1393
多叉树的构建，条件查询，新增，删除，修改等详细操作
算法篇：树之翻转树
zhghost的专栏
08-05 1244
算法：个人觉得这种类型题目的根本在于对题目的理解，所以理解翻转二叉树的定义就很重要。我们先看下什么是翻转二叉树：翻转的意思就是根节点不变，左右子树交换位置，当然这里的左右子树也得是翻转...
翻转树
javalj的博客
01-20 284
package tree.reverseTree; import tree.Node; import tree.myavl.BalanceTree; /** * Created by lijie35 on 2020-01-20 2:15 PM . */ public class ReverseTree { public static void main(String[] args)...
算法:Invert Binary Tree(翻转二叉树)
AI架构师易筋
03-15 1123
说明 算法：Invert Binary Tree LeetCode地址：https://leetcode.com/problems/invert-binary-tree/ 题目： Invert a binary tree. Example: Input: 4 / \ 2 7 / \ / \ 1 3 6 9 Output: 4 / ...
LeetCode_617_合并二叉树
Fitz的博客
10-16 153
题目链接 https://leetcode-cn.com/problems/merge-two-binary-trees/ 解题思路 如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空； 如果两个二叉树的对应节点只有一个为空，则合并后的二叉树的对应节点为其中的非空节点； 如果两个二叉树的对应节点都不为空，则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和，此时需要显性合并两个节点。 对一个节点进行合并之后，还要对该节点的左右子树分别进行合并。这是一个递归的过程
多叉树的前序遍历_多叉树的创建和遍历(为Trie树做准备)
weixin_39974223的博客
01-14 573
trie树实际上是一种多叉树的应用,Trie树是用来解决,搜索引擎中,输入前缀可以给出提示词的非常好的解决方案在实现trie书算法以前,我们先回顾温习下,多叉树的实现和遍历(对于我们trie树的实现和便利帮助很大),这里就不说普通二叉树,因为原理一样,但相对简单下面是算法实现,这个算法参考了这本书中的描述和定义,用了一个很节省空间的结构定义并没有在父节点中存储所有的子节点,而是存储了节点的链表,一...
226. Invert Binary Tree（翻转树）
Iamthedoctor123的博客
02-23 527
Invert a binary tree. 4 / \ 2 7 / \ / \ 1 3 6 9 to 4 / \ 7 2 / \ / \ 9 6 3 1 Trivia: This problem was inspired by this original tweet by Max Howell: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值