已知二叉树的先序(后序)遍历和中序遍历建立二叉树

最新推荐文章于 2024-05-31 10:23:00 发布
最新推荐文章于 2024-05-31 10:23:00 发布
阅读量5.6k 收藏 12
点赞数 4
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/I_believe_CWJ/article/details/80408905
版权

已知二叉树的前序遍历和中序遍历，如何得到它的后序遍历？

对一棵二叉树进行遍历，我们可以采取3中顺序进行遍历，分别是前序遍历、中序遍历和后序遍历。这三种方式是以访问父节点的顺序来进行命名的。假设父节点是N，左节点是L，右节点是R，那么对应的访问遍历顺序如下：

 

  • 前序遍历    N－>L－>R
  • 中序遍历    L－>N－>R
  • 后序遍历    L－>R－>N

/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

所以，对于以下这棵树，三种遍历方式的结果是：

 

  • 前序遍历    ABCDEF
  • 中序遍历    CBDAEF
  • 后序遍历    CDBFEA

已知二叉树的前序遍历和中序遍历，如何得到它的后序遍历

其实，只要知道其中任意两种遍历的顺序，我们就可以推断出剩下的一种遍历方式的顺序，这里我们只是以：知道前序遍历和中序遍历，推断后序遍历作为例子，其他组合方式原理是一样的。要完成这个任务，我们首先要利用以下几个特性：

  • 特性A，对于前序遍历，第一个肯定是根节点；
  • 特性B，对于后序遍历，最后一个肯定是根节点；
  • 特性C，利用前序或后序遍历，确定根节点，在中序遍历中，根节点的两边就可以分出左子树和右子树；
  • 特性D，对左子树和右子树分别做前面3点的分析和拆分，相当于做递归，我们就可以重建出完整的二叉树；

我们以一个例子做一下这个过程，假设：

  • 前序遍历的顺序是: CABGHEDF
  • 中序遍历的顺序是: GBHACDEF

第一步，我们根据特性A，可以得知根节点是C，然后，根据特性C，我们知道左子树是：GHBA，右子树是：DEF。

                        C
                      /     \
               GBHA   DEF

第二步，取出左子树，左子树的前序遍历是：ABGH，中序遍历是：GBHA，根据特性A和C，得出左子树的父节点是A，并且A没有右子树。

                        C
                      /     \
                   A    DEF

                 /

            GBH

第三步，使用同样的方法，前序是BGH，中序是GBH，得出父节点是B，G和H分别是左右节点。

                       C
                      /     \
                   A    DEF

                 /

            B

          /    \

       G      H

第四步，回到右子树，它的前序是EDF，中序是DEF，依然根据特性A和C，得出父节点是E，左右节点是D和F。

                      C
                      /     \
                   A        E

                 /          /    \

            B           D      F

          /    \

       G      H

到此，我们得到了这棵完整的二叉树，因此，它的后序遍历就是：GHBADFEC。

因此我们按照上面的思路，采用递归的方法建树即可完成，下面给出代码，并有例题，有兴趣者可以去试试！

 

 

先序+中序建树过程：

//如果不知道substr函数作用的同学自行百度吧

void build1(node* &t, string pre, string mid)
{
    if(pre.length() == 0) {
        t = NULL;
        return;
    }
    char f = pre[0]; //根节点
    int idx = mid.find(f);
    string ml = mid.substr(0, idx); //左子树的中序
    string mr = mid.substr(idx+1);  //右子树的中序
    int L = ml.length();
    int R = mr.length();
    string pl = pre.substr(1, L); //左子树的前序
    string pr = pre.substr(L+1);  //右子树的前序
    t = new node;
    if(t) {
        t->data = f;
        build1(t->l, pl, ml); //递归建造左子树
        build1(t->r, pr, mr); //递归建造右子树
    }
}

 

例题：POJ 2255-Tree Recovery

AC代码：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<math.h>
#include<stdlib.h>
#include<queue>
#include<map>
#include<set>
#define bug printf("*********\n");
#define mem0(a) memset(a, 0, sizeof(a));
#define mem1(a) memset(a, -1, sizeof(a));
#define in1(a) scanf("%d" ,&a);
#define in2(a, b) scanf("%d%d", &a, &b);
#define out1(a) printf("%d\n", a);
#define out2(a, b) printf("%d %d\n", a, b);
using namespace std;
typedef long long LL;
typedef pair<int, int> par;
const int mod = 1e9+7;
const int INF = 1e9+7;
const int N = 1000010;
const double pi = 3.1415926;

string mid, pre;

struct node
{
    int data;
    node *l;
    node *r;
};

void build(node* &t, string pre, string mid)
{
    if(pre.length() == 0) {
        t = NULL;
        return;
    }
    char f = pre[0];
    int idx = mid.find(f);
    string ml = mid.substr(0, idx);
    string mr = mid.substr(idx+1);
    int L = ml.length();
    int R = mr.length();
    string pl = pre.substr(1, L);
    string pr = pre.substr(L+1);
    t = new node;
    if(t != NULL) {
        t->data = f;
        build(t->l, pl, ml);
        build(t->r, pr, mr);
    }
}

void post_vis(node *t)
{
    if(t != NULL) {
        post_vis(t->l);
        post_vis(t->r);
        printf("%c", t->data);
    }
}

int main()
{
    while(cin>>pre>>mid) {
        node *tree;
        build(tree, pre, mid);
        post_vis(tree);
        printf("\n");
    }
    return 0;
}

 

 

 

另外可能我们有时候还会碰到已知后序+中序让你建树的题目，这个前面的差不多，只是在求左右子树的时候稍有不同，下面也给出代码：

void build2(node* &t, string post, string mid)
{
    if(post.length() == 0) {
        t = NULL;
        return;
    }
    int len = post.length();
    char f = post[len-1];
    int idx = mid.find(f);
    string ml = mid.substr(0, idx);
    string mr = mid.substr(idx+1);
    int L = ml.length();
    int R = mr.length();
    string pl = post.substr(0, L);
    string pr = post.substr(L, R);
    t = new node;
    if(t) {
        t->data = f;
        build2(t->l, pl, ml);
        build2(t->r, pr, mr);
    }
}

最后给出两种方式建树和遍历的测试代码，并附有测试数据：DBACEGF ABCDEFG ACBFGED

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<math.h>
#include<stdlib.h>
#include<queue>
#include<map>
#include<set>
#define bug printf("*********\n");
#define mem0(a) memset(a, 0, sizeof(a));
#define mem1(a) memset(a, -1, sizeof(a));
#define in1(a) scanf("%d" ,&a);
#define in2(a, b) scanf("%d%d", &a, &b);
#define out1(a) printf("%d\n", a);
#define out2(a, b) printf("%d %d\n", a, b);
using namespace std;
typedef long long LL;
typedef pair<int, int> par;
const int mod = 1e9+7;
const int INF = 1e9+7;
const int N = 1000010;
const double pi = 3.1415926;

string mid, pre, post;

struct node
{
    int data;
    node *l;
    node *r;
};

//如果不知道substr函数作用的同学自行百度吧

void build1(node* &t, string pre, string mid)
{
    if(pre.length() == 0) {
        t = NULL;
        return;
    }
    char f = pre[0]; //根节点
    int idx = mid.find(f);
    string ml = mid.substr(0, idx); //左子树的中序
    string mr = mid.substr(idx+1);  //右子树的中序
    int L = ml.length();
    int R = mr.length();
    string pl = pre.substr(1, L); //左子树的前序
    string pr = pre.substr(L+1);  //右子树的前序
    t = new node;
    if(t) {
        t->data = f;
        build1(t->l, pl, ml); //递归建造左子树
        build1(t->r, pr, mr); //递归建造右子树
    }
}

void build2(node* &t, string post, string mid)
{
    if(post.length() == 0) {
        t = NULL;
        return;
    }
    int len = post.length();
    char f = post[len-1];
    int idx = mid.find(f);
    string ml = mid.substr(0, idx);
    string mr = mid.substr(idx+1);
    int L = ml.length();
    int R = mr.length();
    string pl = post.substr(0, L);
    string pr = post.substr(L, R);
    t = new node;
    if(t) {
        t->data = f;
        build2(t->l, pl, ml);
        build2(t->r, pr, mr);
    }
}

void pre_vis(node *t)
{
    if(t) {
        printf("%c", t->data);
        pre_vis(t->l);
        pre_vis(t->r);
    }
}

void mid_vis(node *t)
{
    if(t) {
        mid_vis(t->l);
        printf("%c", t->data);
        mid_vis(t->r);
    }
}

void post_vis(node *t)
{
    if(t) {
        post_vis(t->l);
        post_vis(t->r);
        printf("%c", t->data);
    }
}

void cen_vis(node *t)
{
    queue<node*> q;
    q.push(t);
    while(!q.empty()) {
        node *cur;
        cur = q.front();
        q.pop();
        if(cur) {
            printf("%c", cur->data);
            q.push(cur->l);
            q.push(cur->r);
        }
    }
}

int main()
{
    while(cin>>pre>>mid>>post) {
        node *tree1, *tree2;
        build1(tree1, pre, mid);
        printf("先序+中序建树完成！\n");
        printf("先序遍历：");
        pre_vis(tree1);
        printf("\n");
        printf("中序遍历：");
        mid_vis(tree1);
        printf("\n");
        printf("后序遍历：");
        post_vis(tree1);
        printf("\n");
        printf("层序遍历：");
        cen_vis(tree1);
        printf("\n");

        build2(tree2, post, mid);
        printf("后序+中序建树完成！\n");
        printf("先序遍历：");
        pre_vis(tree2);
        printf("\n");
        printf("中序遍历：");
        mid_vis(tree2);
        printf("\n");
        printf("后序遍历：");
        post_vis(tree2);
        printf("\n");
        printf("层序遍历：");
        cen_vis(tree2);
        printf("\n");
    }
    return 0;
}

 

 

 

I_believe_CWJ
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数据结构C++二叉树的先序遍历、中序遍历和后序遍历实现
12-06
数据结构C++二叉链表的先序遍历、中序遍历和后序遍历实现
已知一棵二叉树的前序遍历以及中序遍历顺序，求这棵树的后序遍历
sally的jerry
07-19 7606
已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树；已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树；注意已知前序和后序遍历，是不能确定一棵二叉树的。httpshttpshttps。...
已知二叉树的前序、中序遍历，求二叉树的后序遍历
yuhaomogui的博客
06-05 1万+
已知二叉树的前序、中序遍历，求二叉树的后序遍历，递归方式解决。
二叉树（先序，后序，层次）建立及（先序，中序，后序，层次遍历）
最新发布
m0_60939919的博客
05-31 748
个人电子笔记，内容多有雷同---PS：中序创建二叉树是不存在的,因为中序无法确定一棵唯一的二叉树,即可能有两棵或多棵不同的二叉树,它们的中序是一样的。
leetcode：889. 根据前序和后序遍历构造二叉树
OceanStar的博客
11-22 3725
题目来源 889. 根据前序和后序遍历构造二叉树 题目描述 题目解析 我们知道，在前序遍历的时候，根节点是第一个输出，而在后序遍历中，根节点是最后一个输出； 那么我们可以利用前序遍历来构建Tree，然后通过后续遍历来检验当前树是否构建完毕。 首先我们创建一个节点作为 root，root = TreeNode(pre[preIndex])当 root.val == post[posIndex]时, 意味着我们已经构建完毕了当前子树，如果当前子树没有构建完毕，那么我们就递归的构建左右子树。 具体代码: /**
二叉树遍历（已知前序和后序遍历，求中序遍历的可能的序列数）
我要出家当道士
03-19 2万+
题目描述Description 我们都很熟悉二叉树的前序、中序、后序遍历，在数据结构中常提出这样的问题：已知一棵二叉树的前序和中序遍历，求它的后序遍历，相应的，已知一棵二叉树的后序遍历和中序遍历序列你也能求出它的前序遍历。然而给定一棵二叉树的前序和后序，你却不能确定其中序遍历序列，考虑如下图中的几棵二叉树： 所有这些二叉树都有着相同的前序遍历和后序遍历，但中序遍历却不相...
通过前中后序遍历还原二叉树图形
qq_42643887的博客
12-16 1410
知道前序遍历和中序遍历，推断后序遍历作为例子，其他组合方式原理是一样的。要完成这个任务，我们首先要利用以下几个特性： 特性A，对于前序遍历，第一个肯定是根节点； 特性B，对于后序遍历，最后一个肯定是根节点； 特性C，利用前序或后序遍历，确定根节点，在中序遍历中，根节点的两边就可以分出左子树和右子树； 特性D，对左子树和右子树分别做前面3点的分析和拆分，相当于做递归，我们就可以重建出完整的二叉树； ...
已知二叉树的前序和中序遍历，打印后序遍历
03-26
这里我们将重点讨论如何在已知二叉树的前序和中序遍历的情况下，通过非递归算法实现后序遍历。 **前序遍历**：根节点 -> 左子树 -> 右子树 **中序遍历**：左子树 -> 根节点 -> 右子树 **后序遍历**：左子树 -> 右子...
C++数据结构已知二叉树的前序遍历与中序遍历结果求后序遍历.pdf
11-25
最后，使用递归函数post来遍历二叉树并输出后序遍历序列。 10. 递归函数的应用：递归函数是解决二叉树问题的常用方法。通过递归函数，可以实现二叉树的构建和遍历。在给定的代码中，create函数用于构建二叉树，post...
二叉树的操作 建立 删除 中序，先序 后序遍历
12-05
本节将详细介绍二叉树的操作，包括建立、删除以及三种遍历方式：中序遍历、先序遍历和后序遍历。 1. **二叉树的建立** - **动态建立**：通常在编程中，我们可以通过动态内存分配创建二叉树的节点，然后根据需求...
二叉树已知后序和中序遍历求前序遍历，C++代码
12-02
二叉树已知后序和中序遍历求前序遍历，C++编写已通过编译
已知二叉树先序遍历和后序遍历序列，求可能的中序遍历序列及方案数
牧空的博客
06-02 2009
分析 参考 理论依据在参考中,这里简单说明一下 假设先序遍历序列为Pre,后序遍历的序列为Post记其中一个结点为v,则在Pre中存在以v为开头的最长后缀Pv使得在Post中有以v为结尾的最长前缀Sv与Pv中元素相同 假设先序遍历序列为Pre,后序遍历的序列为Post\\ 记其中一个结点为v,则在Pre中存在以v为开头的最长后缀P_v\\ 使得在Post中有以v为结尾的最长前缀S_v与P_v中元素相同 假设先序遍历序列为Pre,后序遍历的序列为Post记其中一个结点为v,则在Pre中存在以v为开头的最长后缀
根据前序后序遍历求出二叉树
蜡笔小新1980的博客
02-26 543
给定两个整数数组，preorder和postorder，其中preorder是一个具有值的二叉树的前序遍历，postorder是同一棵树的后序遍历，重构并返回二叉树。
【二叉树】根据前序和后序遍历构造二叉树
豪冷的博客
06-15 2083
题目 给定两个整数数组 preorder 和 postorder 其中 preorder 是一个具有 无重复 值的 二叉树的前序遍历 postorder 是同一棵树的后序遍历 重构并返回二叉树 如果存在多个答案，您可以返回其中 任何 一个...
根据二叉树的先序、中序、后序遍历构建二叉树-图文详解
梦想不会灭
05-11 1万+
引言：根据一颗二叉树，可以得出他的先序、中序、后序三种遍历方式，那么如果我们知道了他的前序、中序遍历，如何绘制出这颗二叉树呢？ 1、二叉树三种遍历方式的特性 特性A，对于前序遍历，第⼀个肯定是根节点； 特性B，对于后序遍历，最后⼀个肯定是根节点； 特性C，利⽤前序或后序遍历，确定根节点，在中序遍历中，根节点的两边就可以分出左⼦树和右⼦树； 特性D，对左⼦树和右⼦树分别做前⾯3点的分析和拆分，相当于做递归，我们就可以重建出完整的⼆叉树； 2、根据特性构建二叉树 例：已知一颗二叉树的前序遍历和中序遍历.
二叉树：已知前序序列与后序序列建树
JasonRaySHD的博客
02-08 9437
二叉树：已知前序与后序建树 已知前序与中序、后序与中序建树是常遇到的算法问题。若已知前序序列与后序序列，要求输出满足条件的树的个数或者输出所有可能的树的中序序列，该怎么解决？下面我们一步步讨论这个问题。 首先，已知一个树的结点数n，共有多少种树形？（或者，已知一颗树的先序/中序/后序序列，共有多少种树形？） 答案是Cmn/(n+1)C_{m}^{n}/(n+1)Cmn​/(n+1)种。点这里了解一...
已知中序遍历和后序遍历，画出此二叉树
热门推荐
BigData_Mining的博客
07-17 3万+
知道中序遍历和后续遍历，如何画出二叉树，并写出前序遍历。要是知道前序和后续遍历，不能确定唯一的二叉树！ 步骤： 通过例子来说明： 已知中序遍历：HDMIBJNEAFKCG.后续遍历：HMIDNJEBKFGCA.求出此二叉树。 1）通过后续遍历知道A是根，C是A的右子树。HDMIBJE是A的左子树部分，FKCG是右子树部分。B则是A的左子树； 2）接着看A的右子树部分KFGC，C是根，从...
已知先序后序遍历找n种二叉树问题
wyxwyx469410930的博客
11-01 3473
Description：二叉树是一种特殊而重要的结构，有着广泛的应用。二叉树或者是一个结点，或者有且仅有一个结点为二叉树的根，其余结点被分成两个互不相交的子集，一个作为左子集，另一个作为右子集，每个子集又是一个二叉树。遍历一棵二叉树就是按某条搜索路径巡访其中每个结点，使得每个结点均被访问一次，而且仅被访问一次。最常使用的有三种遍历的方式：１．前序遍历：若二叉树为空，则空操作；否则先访问根结点，接着前
已知一个二叉树的前序遍历和中序遍历 求后序遍历
12-11
根据二叉树的前序遍历和中序遍历可以唯一确定一棵二叉树，因此可以通过这两个遍历序列构建出这棵二叉树，然后再进行后序遍历。 具体步骤如下： 1. 根据前序遍历序列确定根节点，假设为root。 2. 在中序遍历序列中找到根节点root的位置，将中序遍历序列分为左子树和右子树两部分，分别对左右子树递归进行步骤1和步骤2，直到序列为空或者只有一个节点。 3. 对于每个节点，先遍历它的左子树，再遍历它的右子树，最后遍历它本身，即可得到后序遍历序列。 下面是Python代码实现： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def buildTree(preorder, inorder): if not preorder or not inorder: return None root_val = preorder[0] root = TreeNode(root_val) root_index = inorder.index(root_val) root.left = buildTree(preorder[1:root_index+1], inorder[:root_index]) root.right = buildTree(preorder[root_index+1:], inorder[root_index+1:]) return root def postorderTraversal(root): if not root: return [] stack = [root] res = [] while stack: node = stack.pop() res.append(node.val) if node.left: stack.append(node.left) if node.right: stack.append(node.right) return res[::-1] preorder = [1, 2, 4, 5, 3, 6, 7] inorder = [4, 2, 5, 1, 6, 3, 7] root = buildTree(preorder, inorder) postorder = postorderTraversal(root) print(postorder) # 输出：[4, 5, 2, 6, 7, 3, 1] ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值