剑指Offer - 面试题7：重构二叉树 （力扣 - 105、从前序与中序遍历序列构造二叉树）

最新推荐文章于 2022-07-28 16:51:26 发布
最新推荐文章于 2022-07-28 16:51:26 发布
阅读量256 收藏
点赞数 1
分类专栏： # 剑指Offer系列 # LeetCode 文章标签： 二叉树 指针 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45254369/article/details/116572044
版权

题目

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如：输入前序遍历序列{1，2，4，7，3，5，6，8}和中序遍历序列{4，7，2，1，5，3，8，6}，则重建二叉树如下图。返回该二叉树的头节点。

    3
   / \
  9  20
    /  \
   15   7

二叉树定义如下：

struct BinaryTreeNode
{
	int m_nValue;
	BinaryTreeNode* m_pLeft;
	BinaryTreeNode* m_pRight;
};

分析

递归

首先画出先序遍历和中序遍历的结构图，由此我们可以发现只要计算出根节点在中序中的位置，所有的位置都可以表示出来
在这里插入图片描述
假设我们通过遍历得到lNum
根的左子树区域为：先序 [preorder[1] ,preorder[1+lNum] ], 中序[inorder[0],inorder[lNum]];
根的右子树区域为：先序 [preorder[1+lNum] ,preorder[length-1]], 中序[inorder[lNum+1 ],inorder[length-1]];
因为先序和中序距离一样，我们可以只拿俩数组的首地址，和子树长度即可。
C

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<math.h>
#include<assert.h>

#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType;  /* 树结点的数据类型，目前暂定为整型 */

struct BinaryTreeNode
{
	TElemType m_nValue;
	struct BinaryTreeNode* m_pLeft, * m_pRight;//左右孩子节点
};

void Print(TElemType n)
{
	printf("%d ", n);
}

void Preorder(BinaryTreeNode* root)//前序遍历
{
	if (NULL == root)
	{
		return;
	}

	Print(root->m_nValue);
	Preorder(root->m_pLeft);
	Preorder(root->m_pRight);
}
void Inorder(BinaryTreeNode* root)//中序输出
{
	if (root == NULL)
	{
		return;
	}

	Inorder(root->m_pLeft);
	Print(root->m_nValue);
	Inorder(root->m_pRight);
}

struct BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
{
	//参数非法 以及 递归结束条件
	if (NULL == preorder || NULL == inorder || length <= 0 )
	{
		return NULL;
	}

	int i = 0;			//用于遍历查找中序数组中根的位置
	int val = 0;		//当前节点的值
	int lNum = 0;		//左子树长度
	int rNum = 0;		//右子树长度

	struct BinaryTreeNode* node = (struct BinaryTreeNode*)malloc(sizeof(struct BinaryTreeNode));
	if (NULL == node)
	{
		perror("空间申请失败！\n");
		exit(EXIT_FAILURE);
	}

	val = preorder[0];

	//在中序数组中查找当前节点值的位置
	for (i = 0; i < length; i++)
	{
		if (val == inorder[i])
		{
			break;
		}
		lNum++;
	}
	rNum = length - lNum - 1;

	node->m_nValue = val;
	node->m_pLeft = Construct(&preorder[1], &inorder[0], lNum);
	node->m_pRight = Construct(&preorder[lNum + 1], &inorder[lNum + 1], rNum);
	
	return node;
}

int main()
{
	int pre[] = { 1,2,4,7,3,5,6,8 };
	int ino[] = { 4,7,2,1,5,3,8,6 };
	struct BinaryTreeNode * root = Construct(pre, ino, sizeof(ino) / sizeof(ino[0]));

	printf("先序输出:");
	Preorder(root);
	printf("\n中序输出:");
	Inorder(root);

	return 0;
}

构造好二叉树后，再次输出验证。
在这里插入图片描述

C++可以用哈希表，拿空间换时间
参数较多：
pleft和pright分别为前序遍历的左右闭区间。
ileft和 iright分别为中序遍历的左右闭区间。
通过前序遍历和pleft找到当前根节点。再通过哈希表找到该节点在中序遍历的位置index。进而可以求出左子树的长度lNum = index - ileft。
需要注意一点：只有index是绝对位置(按照最开始的哈希表做的)，边界下标都会收缩的。
在这里插入图片描述

include<iostream>
#include<map>

using namespace std;

#define MAXSIZE 100		/* 存储空间初始分配量 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType;  /* 树结点的数据类型，目前暂定为整型 */

class BinaryTreeNode
{
public:
	TElemType m_nValue;
	BinaryTreeNode* m_pLeft, * m_pRight;//左右孩子节点

public:
	BinaryTreeNode();
	BinaryTreeNode(TElemType x);
	~BinaryTreeNode();
};

BinaryTreeNode::BinaryTreeNode()
{
	m_nValue = 0;
	m_pLeft = NULL;
	m_pRight = NULL;
}

BinaryTreeNode::BinaryTreeNode(TElemType x)
{
	m_nValue = x;
	m_pLeft = NULL;
	m_pRight = NULL;
}

BinaryTreeNode::~BinaryTreeNode()
{

}

void Print(TElemType n)
{
	cout << n << " ";
}

void CreatTree(BinaryTreeNode** T)
{
	TElemType elem;

	cin >> elem;
	if (elem != 999)
	{
		*T = new BinaryTreeNode();
		if (NULL == T)
		{
			perror("空间申请失败！\n");
			exit(EXIT_FAILURE);
		}
		(*T)->m_nValue = elem;
		CreatTree(&((*T)->m_pLeft));
		CreatTree(&((*T)->m_pRight));
	}
	else
	{
		*T = NULL;
	}
}

void Preorder(BinaryTreeNode* root)//前序遍历
{
	if (NULL == root)
	{
		return;
	}

	Print(root->m_nValue);
	Preorder(root->m_pLeft);
	Preorder(root->m_pRight);
}
void Inorder(BinaryTreeNode* root)//中序输出
{
	if (root == NULL)
	{
		return;
	}

	Inorder(root->m_pLeft);
	Print(root->m_nValue);
	Inorder(root->m_pRight);
}

BinaryTreeNode* ConstructCore(int* preorder, int* inorder, 
	int preorder_left, int preorder_right, int inorder_left, 
	int inorder_right, map<TElemType, int> m)
{
	//参数非法 以及 递归结束条件
	if (NULL == preorder || NULL == inorder || 
		preorder_left < 0 || preorder_right < preorder_left || 
		inorder_left < 0 ||inorder_right < inorder_left)
	{
		return NULL;
	}
	
	// 前序遍历中的第一个节点就是根节点preorder[preorder_index]

	// 按前序遍历preorder_left下标的值作为key找到哈希表对应的value
	// 即中序遍历中该节点的下标
	int inorder_index = m[preorder[preorder_left]];

	BinaryTreeNode* node = new BinaryTreeNode(preorder[preorder_left]);

	//左子树中的节点数目
	int lNum = inorder_index - inorder_left;

	node->m_pLeft = ConstructCore(preorder, inorder, preorder_left + 1, 
			preorder_left + lNum, inorder_left, inorder_index - 1, m);

	node->m_pRight = ConstructCore(preorder, inorder, preorder_left + 1 + lNum,
		preorder_right, 1 + inorder_index, inorder_right, m);

	return node;
}

BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
{
	//参数非法
	if (NULL == preorder || NULL == inorder || length <= 0)
	{
		return NULL;
	}

	map<TElemType, int> m;
	int i = 0;
	for (i = 0; i < length; i++)
	{
		m.insert(make_pair(inorder[i], i));
	}

	return ConstructCore(preorder, inorder, 0, length - 1, 0, length - 1 , m);
}


int main()
{
	int pre[] = { 1,2,4,7,3,5,6,8 };
	int ino[] = { 4,7,2,1,5,3,8,6 };

	BinaryTreeNode* root = Construct(pre, ino, sizeof(ino) / sizeof(ino[0]));

	cout << "先序遍历:";
	Preorder(root);
	cout << endl << "中序遍历：";
	Inorder(root);

	return 0;
}

在这里插入图片描述

迭代

我们可以用一个栈来保存每次遍历的节点。先把根节点preorder[0]放入，然后遍历先序数组，从下标1开始，因为根节点提前创建。再定义一个index用来指向中序数组

  • 若发现栈顶指针指向的值不等于中序指针指向的值,那么说明,先序指向的值为前一个节点的左儿子。如下图

在这里插入图片描述

  • 若发现栈顶指针指向的值等于中序指针指向的值。那么说明左儿子已经完了。那么我们需要更新中序指针。只要栈不空且栈中的值等于当前中序指针指向的值。就一直循环。
    在这里插入图片描述
    当不相等时，就说明接下来的值就是前一个节点的右儿子。所以我们在跟新中序指针时，还需要更新保存栈中的栈顶指针。见下图

在这里插入图片描述

C++

#include<iostream>
#include<stack>

using namespace std;

#define MAXSIZE 100		/* 存储空间初始分配量 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType;  /* 树结点的数据类型，目前暂定为整型 */

class BinaryTreeNode
{
public:
	TElemType m_nValue;
	BinaryTreeNode* m_pLeft, * m_pRight;//左右孩子节点

public:
	BinaryTreeNode();
	BinaryTreeNode(TElemType x);
	~BinaryTreeNode();
};

BinaryTreeNode::BinaryTreeNode()
{
	m_nValue = 0;
	m_pLeft = NULL;
	m_pRight = NULL;
}

BinaryTreeNode::BinaryTreeNode(TElemType x)
{
	m_nValue = x;
	m_pLeft = NULL;
	m_pRight = NULL;
}

BinaryTreeNode::~BinaryTreeNode()
{

}

void Print(TElemType n)
{
	cout << n << " ";
}

void CreatTree(BinaryTreeNode** T)
{
	TElemType elem;

	cin >> elem;
	if (elem != 999)
	{
		*T = new BinaryTreeNode();
		if (NULL == T)
		{
			perror("空间申请失败！\n");
			exit(EXIT_FAILURE);
		}
		(*T)->m_nValue = elem;
		CreatTree(&((*T)->m_pLeft));
		CreatTree(&((*T)->m_pRight));
	}
	else
	{
		*T = NULL;
	}
}

void Preorder(BinaryTreeNode* root)//前序遍历
{
	if (NULL == root)
	{
		return;
	}

	Print(root->m_nValue);
	Preorder(root->m_pLeft);
	Preorder(root->m_pRight);
}
void Inorder(BinaryTreeNode* root)//中序输出
{
	if (root == NULL)
	{
		return;
	}

	Inorder(root->m_pLeft);
	Print(root->m_nValue);
	Inorder(root->m_pRight);
}


BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
{
	if (preorder == NULL || inorder == NULL || length <= 0)
	{
		return 0;
	}

	stack<BinaryTreeNode*> s;
	BinaryTreeNode* root = new BinaryTreeNode(preorder[0]);
	s.push(root);

	int inorder_index = 0;//中序遍历的指针

	for (int i = 1; i < length; i++)//每次循环连接一个节点，还需要连接length-1个。
	{
		BinaryTreeNode* node = s.top();

		if (node->m_nValue != inorder[inorder_index])//不相等，就是左儿子
		{
			node->m_pLeft = new BinaryTreeNode(preorder[i]);
			s.push(node->m_pLeft);
		}
		else
		{
			while (s.empty() != true && s.top()->m_nValue == inorder[inorder_index])
			{
				s.pop();
				node = s.top();//更新父节点
				inorder_index++;//中序遍历指针移动
			}

			//此时i和inorder_index均指向右节点。都可以使用inorder[inorder_index]
			node->m_pRight = new BinaryTreeNode(preorder[i]);
			s.push(node->m_pLeft);
		}
	}
	return root;
}

int main()
{
	int pre[] = { 1,2,4,7,3,5,6,8 };
	int ino[] = { 4,7,2,1,5,3,8,6 };

	BinaryTreeNode* root = Construct(pre, ino, sizeof(ino) / sizeof(ino[0]));

	cout << "先序遍历:";
	Preorder(root);
	cout << endl << "中序遍历：";
	Inorder(root);

	return 0;
}

在这里插入图片描述
本章完!

林夕07
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
剑指offer面试题：输入某二叉树的前序遍历和中序遍历的结果，输出后序遍历结果。
ahfytao
11-03 6044
二叉树的先序，中序，后序如何
7-2 重构二叉树 (10 分)
weixin_53142864的博客
11-05 695
给出两个字符串，分别表示二叉树的先序遍历（根、左子树、右子树）和中序遍历（左子树、根、右子树）的结果。 例如，对于下面的二叉树，先序遍历结果是DBACEGF，中序遍历结果是ABCDEFG。 假定二叉树的每个节点都用大写的字母标识，且对于同一棵二叉树，同一个字母不会用两次。现在请你根据给出的先序遍历和中序遍历，重构这棵二叉树。 输入格式: 输入包含一个或多个测试用例。每个测试用例一行，给出两个字符串，表示对二叉树进行先序遍历和中序遍历的结果。这两个字符串都是由大写字母组成（因此它们的长度不超过26
由先序与中序序列构造二叉树
11-19
已知先序和中序即可唯一确定二叉树，由此构造。
实现由先序、中序序, 中序、后序构造二叉树的算法
11-29
定义二叉树类，封装构造二叉树操作、遍历操作. 实现由先序、中序序列构造二叉树的算法 实现由后序、中序序列构造二叉树的算法
剑指Offer——面试题6：重构二叉树
不爱学习
05-02 313
题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 分析 在二叉树前序遍历序列中，第一个数字总是树的根节点的值。但在中序遍历中，根节点的值在序列中间。所有的左子树都位于根
程序员面试金典 – 面试题 17.12. BiNode（BST中序遍历）
12-21
二叉树数据结构TreeNode可用来表示单向链表（其中left置空，right为下一个链表节点）。 实现一个方法，把二叉搜索树转换为单向链表，要求值的顺序保持不变，转换操作应是原址的，也就是在原始的二叉搜索树上直接修改...
leetcode第685题-leetcode-js:力扣js解题记录
06-30
leetcode第685题 leetcode-js 力扣js解题记录 树 -> 图论 -> 递归 -> 回溯 ...二叉树的中序遍历 ...对称二叉树 ...二叉树的层序遍历 ...二叉树的最大深度 ...二叉树的最小深度 ...翻转二叉树 ...二叉树的前序遍历 ...面试题 16
leetcode减绳子-LeetCode-Offer:力扣优惠去
06-30
面试中常见的算法题 排序和查找算法 冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序、希尔排序、计数排序、桶排序、计数排序 顺序查找、二分查找、插值查找、斐波那契查找、树表查找、分块查找、哈希...
【面试题8】二叉树的下一个节点
01-06
思路：脑中构造出一个树。 1.左子树为父节点； 2.如果一个节点有右子树，下一个节点为右子树的最左结点； 3.如果一个节点无右子树，且为父节点的左子结点，下一个节点为父节点； 4.如果为父节点的右子节点，向上遍历...
leetcode提交记录怎么看-hack-interview-handbook:黑客面试手册
06-30
leetcode提交记录怎么看 ...为什么不用二叉树呢? 在平时的工作中，数据结构和算法的应用到处可见。我来举一个你非常熟悉的例子:如何实 时地统计业务接口的 99% 响应时间? 你可能最先想到，每次查询时，从小到大排序所有
牛客网剑指offer刷题练习之重构二叉树
微凉秋意的博客
07-28 3159
今天分享用C++做算法题的经验，题目来自于牛客网《剑指offer》专栏里的一道二叉树中等难度的算法题。牛客网是一个资源丰富且能够免费刷题、面试的网站，强烈推荐小伙伴们使用，链接已经放在文章开头了。 二叉树的题目大都是和递归有关，认真的做一道题比盲目刷几十道收获要大得多，勤做笔记，善于用思考才会变强！ .........
剑指Offer面试题07：重建二叉树（根据前序遍历和中序遍历还原树）
LifeGoesOn
05-30 242
题目： 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 　3 / 　 \ 9 　 20 / 　 　\ 15 　　7 限制： 0 <= 节点个数 <= 5000 一、二叉树的遍历（复习） 首先，二叉树的前序，中序，后续遍历在数据结构里学习过。 前序遍历的顺序是：中 左 右；
力扣105.从前序与中序遍历序列构造二叉树
s4444sss的博客
03-10 151
105.从前序与中序遍历序列构造二叉树 思路： 通过前序遍历数组的第一个元素得出根节点，并在中序遍历数组中找到根节点，该数组根节点位置左边是左子树，右边是右子树 为了创建左右子树，通过中序数组得出左子树和右子树的范围后，到前序数组中找到左右子树范围并继续获得根节点。想要构建最开始的左右子树，就得构建该左右子树下面的左右子树，依次类推 通过前两点的分析，可以考虑使用递归创建左子树和右子树，此时考虑递归三要素：(1).递归函数的参数和返回值 (2).终止条件 (3).单层递归的逻辑 参数应为左右子树的数组
《剑指Offer》二叉树遍历（前中后序、广度优先、深度优先）
try_again_later的博客
05-31 398
0前言 7 重建二叉树（递归） 8 二叉树的下一节点 26 树的子结构（递归） 27 二叉树的镜像（递归） 28 对称的二叉树（递归） 32 从上到下打印二叉树（广度遍历） 33二叉搜索树的后序遍历序列（递归） 34二叉树中和为某一值的路径（深度遍历、前序遍历首先访问根节点） 37 序列化二叉树（前序遍历）、反序列化二叉树 55 二叉树的深度 7 重建二叉树 题目描述 ...
图解「剑指Offer」之用前序和中序遍历序列构建二叉树
程序员吴师兄的博客
08-29 1407
点击蓝色“五分钟学算法”关注我哟加个“星标”，天天中午 12:15，一起学算法作者 |程序员小吴来源 | 五分钟学算法题目描述 根据一棵树的前序遍历与中序遍历构造二叉树...
根据前序遍历与中序遍历构造二叉树
热门推荐
Nan_Feng726的博客
06-06 1万+
根据一棵树的前序遍历与中序遍历构造二叉树。 思路： 有了前序遍历，首先我们可以知道根节点的值，也就是数组中下标为0的位置，由此创建根节点。 然后在中序遍历中找到根的值所在的下标，切出左右子树的前序和中序。 注意：如果前序遍历的数组长度为0，说明是一棵空树。 下面用具体的例子来说明： 前序：ABCDE 中序：CDBAE 1、首先可以确定A是这棵树的根节点，然后根据中序遍历切出A的左右子树，得到B...
先序+中序创建二叉树
Samven_7的博客
07-07 2969
设计一个程序，根据二叉树的先根序列和中根序列创建一棵用左右指针表示的二叉树 #include <iostream> using namespace std; /*-------------------------二叉树的链式存储---------------------------*/ typedef struct BiTNode { char data; //结点数据域 BiTN...
根据二叉树遍历结果重构二叉树(前序遍历+中序遍历 / 中序遍历+后序遍历 / LeetCode真题)
Lotus_dong的博客
07-05 479
文章目录重构二叉树前序遍历+中序遍历后序遍历+中序遍历前序遍历+后序遍历 重构二叉树 所谓重构二叉树就是根据遍历结果构造还原出原本的二叉树，在二叉树的四种遍历方法(前序遍历、中序遍历、后序遍历、层序遍历)中已经对二叉树的遍历进行了详细的分析，接下来我们就要分析如何根据不同的遍历结果重构出二叉树。 前序遍历的访问顺序：根节点——>前序遍历左子树——>前序遍历右子树 中序遍历的访问顺序：中序遍历左子树——>根节点——>中序遍历右子树 后序遍历的访问顺序：后序遍历左子树——>后序遍历
【剑指Offer_4】输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序
qq_36908841的博客
07-10 2470
题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。解题思路：前序遍历的顺序是 根---左结点---右结点。中序遍历的顺序是 左结点---根---右结点。因此，对于前序遍历序列，其实就是“根”的遍历，1是第一个...
根据前序和中序遍历 构建二叉树，输出后序遍历 前序遍历:ABDECFG 中序遍历:DBEAFCG
最新发布
03-02
根据前序和中序遍历构建二叉树的步骤如下： 1. 前序遍历的第一个元素是根节点，即A。 2. 在中序遍历中找到根节点A的位置，将中序遍历分为左子树和右子树两部分。 左子树的中序遍历为：DBE，右子树的中序遍历为：FCG...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林夕07

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值