C++二叉树遍历、重建

已于 2023-03-25 18:04:34 修改
阅读量149 收藏
点赞数
分类专栏： C++ 文章标签： c++ 数据结构 开发语言
于 2023-03-25 18:03:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Astra1Requiem/article/details/129747091
版权

二叉树总结

节点和树

//树节点
struct _Tree
{
	int value = 0;
	_Tree* lchild = nullptr;
	_Tree* rchild = nullptr;
	_Tree(int i = 0) :value(i), lchild(nullptr), rchild(nullptr) {};
};
//建立原始树
_Tree createTree(_Tree root) {
	root.value = 4;
	static _Tree child2(2), child5(5), child1(1), child7(7), child9(9);
	root.lchild = &child2;
	child2.rchild = &child1;
	root.rchild = &child5;
	child5.lchild = &child7;
	child5.rchild = &child9;
	std::cout << "创建树成功！" << std::endl;
	cout << root.value << root.lchild->value << root.rchild->value
		<< root.lchild->rchild->value << root.rchild->lchild->value << root.rchild->rchild->value << endl;
	return root;
}

深度优先遍历

递归方法

先序，中序，后序
  • 先序，中序，后序遍历主要是根据根节点输出位置决定
  • 由于递归方法较为简单，这里只总结先序遍历。先序遍历即以“根——左——右”的顺序输出，通过递归方法输出即可。
//先序遍历
void MLR(_Tree* root) {
	if (root != nullptr) {
		cout << root->value << " ";
		MLR(root->lchild);
		MLR(root->rchild);
	}
	return;
}
//中序遍历
void LMR(_Tree* root) {
	if (root != nullptr) {	
		LMR(root->lchild);
		cout << root->value << " ";
		LMR(root->rchild);
	}
	return;
}
//后序遍历
void LRM(_Tree* root) {
	if (root != nullptr) {
		LRM(root->lchild);		
		LRM(root->rchild);
		cout << root->value << " ";
	}
	return;
}

非递归方法

先序，中序

对于先序和中序遍历，其利用指针遍历节点的逻辑是一致的，逻辑如下：

  1. 利用栈先进后出的特性，将根节点入栈，然后让指针指向当前节点的左子树，循环直到左子树为空

  2. 左子树为空时，访问栈顶元素的右子树，然后将栈顶元素出栈

    分析一下这样的入栈顺序：先是根节点入栈，然后是左节点，若左节点的左子树为空，则左节点出栈，然后访问左节点的右节点；这样保证了（1）根节点比左节点先入栈（2）同级的左节点比右节点先入栈。

假设我们要将遍历到的树依次存储在一个数组中，区分先序和中序遍历不同点在于先存入谁和后存入谁的问题：

对于先序遍历而言，先存根节点，再存左节点，而入栈顺序就是这样的，所以在入栈时存入即可保证了“根——左——右”的顺序。

对于中序遍历而言，先存左节点，再存根节点，在第二步存入出栈的元素即可（因为第一步完成时，即保证了栈顶元素的左子树为空）

可以简单的理解：在第一步存入得到先序遍历结果，在第二步存入得到中序遍历结果。

代码如下：

//非递归先序遍历二叉树
vector<int>* MLR2(_Tree* root, vector<int>* ans) {
	stack<_Tree> stk;
	_Tree* root1 = root;
	while (root1 != nullptr || !stk.empty()) {
		if (root1 != nullptr) {
			ans->push_back(root1->value);
			stk.push(*root1);
			root1 = root1->lchild;
		}
		else {
			_Tree node = stk.top();
			stk.pop();
			root1 = node.rchild;
		}
	}
	return ans;
}

vector<int>* LMR2(_Tree* root, vector<int>* ans) {
	stack<_Tree> stk;
	_Tree* node = root;
	while (node != nullptr || !stk.empty()) {
		if (node != nullptr) {
			stk.push(*node);
			node = node->lchild;
		}
		else {
			_Tree temp = stk.top();
			ans->push_back(temp.value);
			node = temp.rchild;
			stk.pop();
		}
	}
	return ans;
}
后序遍历

对于后序遍历，其利用指针遍历节点的逻辑与先序，中序是不太一样的，逻辑如下：

  1. 利用栈先进后出的特性，将根节点入栈，然后让指针指向当前节点的左子树，循环直到左子树为空

  2. 左子树为空时，将当前指针指向栈顶元素，若栈顶元素的右子树非空且未被访问，则访问栈顶元素的右子树（即让当前指针指向右子树）；若其为空或者已经被访问，则将栈顶元素出栈，用一个指针记录当前指针，然后将当前指针置零。

    第二步这样做的原因是为了使得某个节点的右子树不为空时重复入栈。

    代码如下：

    vector<int>* LRM2(_Tree* root, vector<int>* ans) {
	//非递归后序遍历，比较特殊，需要记录上一时刻是否访问了右节点
	//这里不记录左节点是因为tip1处访问的是左节点，先天决定了在根节点pop前左节点就pop了，且不会再访问已经pop的左节点
	_Tree* p = root, * r = nullptr;
	stack<_Tree*> s;
	while (p || !s.empty()) {
		if (p) {//走到最左边
			s.push(p);
			p = p->lchild;
		}
		else {
			p = s.top();
			if (p->rchild && p->rchild != r)//右子树存在，未被访问
				p = p->rchild;
			else {
				s.pop();
				ans->push_back(p->value);
				r = p;//记录最近访问过的节点
				p = nullptr;//节点访问完后，重置p指针
			}
		}//else
	}//while
	return ans;
}

广度优先遍历（层次遍历）

层次优先遍历即从上向下，从左往右依次遍历，这时用指针来挨个遍历较为麻烦，指针需要不停的“上窜下跳”，这时可以利用队列。逻辑如下：

  1. 跟节点入队
  2. 循环将队头的（非空）左右节点依次入队，然后队头出队，直到队列为空

出队的顺序即为层次遍历的结果，代码如下：

vector<int>* LT(_Tree*root,vector<int>*ans) {
	queue<_Tree>qee;
	if (root==nullptr) return ans;
	qee.push(*root);
	while (!qee.empty()) {
		_Tree temp = qee.front();
		ans->push_back(temp.value);
		qee.pop();
		if (temp.lchild!=nullptr) {
			qee.push(*(temp.lchild));
		}
		if (temp.rchild!=nullptr) {
			qee.push(*(temp.rchild));
		}	
	}
	return ans;
}

重建二叉树

递归重建法

​ 这里假设我们已知前序遍历anspre和中序遍历结果ansmid。

  1. 这颗树的根节点为前序遍历的首个元素k
  2. 根据k在中序遍历中的位置Index，其左边的是左子树的中序遍历结果ansmidL；右边的是右子树的中序遍历结果ansmidR
  3. 由元素个数关系结合Index可知，前序遍历的下标**[1-Index]为左子树的前序遍历结果anspreL**，下标**[Index–最后]是右子树的前序遍历结果anspreR**
  4. 使用递归重建左子树和右子树

代码如下：

//递归重建法
_Tree* rebuildTree(vector<int>anspre, vector<int>ansmid) {
	if (anspre.empty() || (anspre.size() != ansmid.size())) return nullptr;
	_Tree *node = new _Tree(anspre[0]);
	size_t index = 0;
	for (int i = 0; i < anspre.size(); i++) {
		if (ansmid[i] == anspre[0]) {
			index = i;
			break;
		}
	}
	//记录左/右子树的前序，后序遍历
	vector<int>anspreL, anspreR, ansmidL, ansmidR;
	for (size_t i = 0; i < index; i++) {
		anspreL.push_back(anspre[i + 1]);
		ansmidL.push_back(ansmid[i]);
	}
	for (size_t i = index + 1; i < anspre.size(); i++) {
		anspreR.push_back(anspre[i]);
		ansmidR.push_back(ansmid[i]);
	}
	//递归
	node->lchild = rebuildTree(anspreL, ansmidL);
	node->rchild = rebuildTree(anspreR, ansmidR);
	return node;
}

这里由于重建时使用new将树重建在堆上，所以最后也要将其delete掉，代码如下:

//对于new出来的树要delete
void deleteTree(_Tree* root) {
	if (root != nullptr) {
		deleteTree(root->lchild);
		deleteTree(root->rchild);
		delete root;
		root = nullptr;
	}
	return;
}

完整代码

#include<iostream>
#include<vector>
#include<stack>
#include<queue>
using namespace std;

//树节点
struct _Tree
{
	int value = 0;
	_Tree* lchild = nullptr;
	_Tree* rchild = nullptr;
	_Tree(int i = 0) :value(i), lchild(nullptr), rchild(nullptr) {};
};
//建立原始树
_Tree createTree(_Tree root) {
	root.value = 4;
	static _Tree child2(2), child5(5), child1(1), child7(7), child9(9);
	root.lchild = &child2;
	child2.rchild = &child1;
	root.rchild = &child5;
	child5.lchild = &child7;
	child5.rchild = &child9;
	std::cout << "创建树成功！" << std::endl;
	cout << root.value << root.lchild->value << root.rchild->value
		<< root.lchild->rchild->value << root.rchild->lchild->value << root.rchild->rchild->value << endl;
	return root;
}

//先序遍历
void MLR(_Tree* root) {
	if (root != nullptr) {
		cout << root->value << " ";
		MLR(root->lchild);
		MLR(root->rchild);
	}
	return;
}
//中序遍历
void LMR(_Tree* root) {
	if (root != nullptr) {	
		LMR(root->lchild);
		cout << root->value << " ";
		LMR(root->rchild);
	}
	return;
}
//后序遍历
void LRM(_Tree* root) {
	if (root != nullptr) {
		LRM(root->lchild);		
		LRM(root->rchild);
		cout << root->value << " ";
	}
	return;
}

//非递归先序遍历二叉树

vector<int>* MLR2(_Tree* root, vector<int>* ans) {
	stack<_Tree> stk;
	_Tree* root1 = root;
	while (root1 != nullptr || !stk.empty()) {
		if (root1 != nullptr) {
			ans->push_back(root1->value);
			stk.push(*root1);
			root1 = root1->lchild;
		}
		else {
			_Tree node = stk.top();
			stk.pop();
			root1 = node.rchild;
		}
	}
	return ans;
}

vector<int>* LMR2(_Tree* root, vector<int>* ans) {
	stack<_Tree> stk;
	_Tree* node = root;
	while (node != nullptr || !stk.empty()) {
		if (node != nullptr) {
			stk.push(*node);
			node = node->lchild;
		}
		else {
			_Tree temp = stk.top();
			ans->push_back(temp.value);
			node = temp.rchild;
			stk.pop();
		}
	}
	return ans;
}

vector<int>* LRM2(_Tree* root, vector<int>* ans) {
	//非递归后序遍历，比较特殊，需要记录上一时刻是否访问了右节点
	//这里不记录左节点是因为tip1处访问的是左节点，先天决定了在根节点pop前左节点就pop了，且不会再访问已经pop的左节点
	_Tree* p = root, * r = nullptr;
	stack<_Tree*> s;
	while (p || !s.empty()) {
		if (p) {//走到最左边
			s.push(p);
			p = p->lchild;
		}
		else {
			p = s.top();
			if (p->rchild && p->rchild != r)//右子树存在，未被访问
				p = p->rchild;
			else {
				s.pop();
				ans->push_back(p->value);
				r = p;//记录最近访问过的节点
				p = nullptr;//节点访问完后，重置p指针
			}
		}//else
	}//while
	return ans;
}

//层次遍历即广度优先
vector<int>* LT(_Tree*root,vector<int>*ans) {
	queue<_Tree>qee;
	if (root==nullptr) return ans;
	qee.push(*root);
	while (!qee.empty()) {
		_Tree temp = qee.front();
		ans->push_back(temp.value);
		qee.pop();
		if (temp.lchild!=nullptr) {
			qee.push(*(temp.lchild));
			//cout << "L:" << endl;
		}
		if (temp.rchild!=nullptr) {
			qee.push(*(temp.rchild));
			//cout << "R:" << endl;
		}	
	}
	return ans;
}


//重建树
//先序和中序可以确定唯一树
//中序和后序可以确定唯一树
//先序和后序无法确定唯一树

//递归重建法
_Tree* rebuildTree(vector<int>anspre, vector<int>ansmid) {
	if (anspre.empty() || (anspre.size() != ansmid.size())) return nullptr;
	_Tree *node = new _Tree(anspre[0]);
	size_t index = 0;
	for (int i = 0; i < anspre.size(); i++) {
		if (ansmid[i] == anspre[0]) {
			index = i;
			break;
		}
	}
	//记录左/右子树的前序，后序遍历
	vector<int>anspreL, anspreR, ansmidL, ansmidR;
	for (size_t i = 0; i < index; i++) {
		anspreL.push_back(anspre[i + 1]);
		ansmidL.push_back(ansmid[i]);
	}
	for (size_t i = index + 1; i < anspre.size(); i++) {
		anspreR.push_back(anspre[i]);
		ansmidR.push_back(ansmid[i]);
	}
	//递归
	node->lchild = rebuildTree(anspreL, ansmidL);
	node->rchild = rebuildTree(anspreR, ansmidR);

	return node;
}

//对于new出来的树要delete
void deleteTree(_Tree* root) {
	if (root != nullptr) {
		deleteTree(root->lchild);
		deleteTree(root->rchild);
		delete root;
		root = nullptr;
	}
	return;
}


int main() {
	vector<int>ansMLR;
	vector<int>ansLMR;
	vector<int>ansLRM;
	//初始树
	_Tree root(4);
	root=createTree(root);

	//递归
	cout << "打印先序遍历:";
	MLR(&root);
	cout << endl;

	cout << "打印中序遍历:";
	LMR(&root);
	cout << endl;

	cout << "打印后序遍历:";
	LRM(&root);
	cout << endl;

	//非递归
	MLR2(&root, &ansMLR);
	cout << "打印非递归先序遍历数组:";
	for (int i = 0; i < ansMLR.size(); i++) {
		cout << ansMLR[i]<<" ";
	}
	cout << endl;

	LMR2(&root, &ansLMR);
	cout << "打印非递归中序遍历数组:";
	for (int i = 0; i < ansLMR.size(); i++) {
		cout << ansLMR[i] << " ";
	}
	cout << endl;

	LRM2(&root, &ansLRM);
	cout << "打印非递归后序遍历数组:";
	for (int i = 0; i < ansLRM.size(); i++) {
		cout << ansLRM[i] << " ";
	}
	cout << endl;

	//层次遍历
	ansLRM.clear();
	LT(&root, &ansLRM);
	cout << "打印层次遍历数组:";
	for (int i = 0; i < ansLRM.size(); i++) {
		cout << ansLRM[i] << " ";
	}
	cout << endl;
	
	//重建树
	_Tree* nodeRebuild=rebuildTree(ansMLR, ansLMR);

	//打印一下先序遍历结果看看是否正确
	cout << "打印先序遍历:";
	MLR(nodeRebuild);
	cout << endl;

	//删除堆上重建的树
	deleteTree(nodeRebuild);
	return 0;
}
YimocJun
关注
专栏目录
重建二叉树[C++版]
爱着瓜瓜的花花的博客
09-14 573
重建二叉树[C++版]问题描述解决思想思想1：树的性质思想2：递归我的代码总结（附）Python实现代码 问题描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 解决思想 首先我们看一下C++版本的...
由前序遍历和中序遍历重建二叉树和C语言模式实现C++继承和多态——题集（十四）
就是爱编程-都有人重名的博客
07-30 996
由前序遍历和中序遍历重建二叉树和C语言模式实现C++继承和多态——题集（十四）        今天分享一下实现由前序遍历和中序遍历重建二叉树和C语言模式实现C++继承和多态的源代码和运行示例。        由前序遍历和中序遍历重建二叉树的源代码和运行示例。（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5） 源代码如下： #include using names
重建二叉树
u012629369的专栏
12-09 567
Problem 78: 重建二叉树 Time Limit:1 Ms| Memory Limit:100 MB Difficulty:0 [Problem] [Rank] Description 题目很简单，给你一棵二叉树的后序和中序序列，求出它的前序序列（So easy!）。 Input 输入有多组数据（少于100组），以文件结尾结束。
重建二叉树——C++
weixin_42809675的博客
06-17 490
重建二叉树 C++
面试题6： 二叉树的重建
wakaka的博客
06-12 404
给定一棵二叉树的前序遍历序列和中序遍历序列，重建该二叉树。
重建二叉树（C++）
田螺姑娘的博客
03-17 1259
重建二叉树 描述   给定节点数为 n 的二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。   例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出如下图所示。 提示: vin.length == pre.length pre 和 vin 均无重复元素 vin出现的元素均出现在 pre里 只需要返回根结点，系统会自动输出整颗树做答案对比 数据范围： 要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n) 示例1
C++基于先序、中序遍历结果重建二叉树的方法
12-26
本文实例讲述了C++基于先序、中序遍历结果重建二叉树的方法。分享给大家供大家参考，具体如下： 题目： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含...
二叉树的遍历问题-C++实现.docx
03-12
二叉树遍历是计算机科学中一种重要的树形数据结构操作。在这个问题中，我们要解决的是根据二叉树的先序遍历（Preorder Traversal）和中序遍历（Inorder Traversal）序列，来求解其后序遍历（Postorder Traversal）...
二叉树的三种遍历方法的非递归实现（c++版）
xbb123456rt的博客
09-04 848
二叉树的前序遍历、中序遍历与后序遍历一直是面试时的常客。这三种遍历方法都有递归实现与非递归实现两种版本。递归实现只需要根据定义书写即可，而非递归实现则会用到其他的数据结构，相对复杂。本文将这三种遍历方法的非递归实现加以总结，以备不时之需。 1.前序遍历 前序遍历的非递归版本需要用到一个栈，用以记录当前遍历节点的右子节点。回退时，获取栈顶节点，继续前序遍历。其c++实现如下所示： void ...
重建二叉树C++
heibai97的博客
02-20 621
重建二叉树C++题目：题解：代码： 题目： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 题解： 代码： /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeN
C++实现重建二叉树
fgs的博客
07-18 349
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 class Solution { public: TreeNode* rebuild(vector<int>& pre, int pre_left, int pre_right, vector<int>& vin, int
二叉树的重建
zhhp1001的博客
03-26 465
class Solution { public: struct TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> in) { int inlen = in.size(); if (inlen == 0) return NULL; vector<int> le...
剑指offer：重建二叉树(C++)
Lavi的专栏
12-03 430
题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 代码： #include &lt;iostream&gt; #include &lt;stdlib.h&gt; #include &lt;string&...
剑指offer——重建二叉树（c++)
SCS199411的博客
06-13 930
题目描述 输入一棵二叉树前序遍历和中序遍历的结果，请重建该二叉树。 注意: 二叉树中每个节点的值都互不相同； 输入的前序遍历和中序遍历一定合法； 样例 给定： 前序遍历是：[3, 9, 20, 15, 7] 中序遍历是：[9, 3, 15, 20, 7] 返回：[3, 9, 20, null, null, 15, 7, null, null, null, null] 思路 先序遍历数组中的第一个数...
使用c++实现二叉树的重建
zhpf225的博客
05-01 527
问题定义: 输入一个二叉树的前序和中序的字符串序列，输出重建二叉树之后的后序遍历结果。 分析： 先根据二叉树的前序和中序的序列进行重建二叉树，然后再进行使用递归进行后续遍历二叉树。 示例代码： #include <iostream> using namespace std; //首先定义一个结构体 struct Node{ struct Node* left; stru...
重建二叉树（C++中等区）
mcc6688的博客
09-09 583
重建二叉树 题目：输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 限制： 0 <= 节点个数 <= 5000 解题思路 首先我的想法是，一般我们看到树的这类问题，可以想想能否用递归的方法解决。这题用递归思想比较好理解。 题目给定的是树的前序和中序，我们首先可以根据树的前序的特性可知
数据结构-重建二叉树
weixin_30735745的博客
07-27 108
#include <iostream> using namespace std; struct BinaryTreeNode{ int data; BinaryTreeNode* lchild; BinaryTreeNode* rchild; }; BinaryTreeNode* Rebuilt(int *pre,int* preE...
二叉树的遍历和重建实验分析
最新发布
05-30
下面是一个基于C++实现的二叉树遍历和重建的实验分析： 1. 实验环境 - 操作系统：Windows 10 - 开发环境：Visual Studio 2019 - 编程语言：C++ 2. 实验过程 2.1 二叉树的遍历 在实验中，我们采用前序遍历的方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值