C++ 树的前序，中序，后序，层序遍历，基于递归，基于循环

最新推荐文章于 2024-09-29 17:52:02 发布

原创最新推荐文章于 2024-09-29 17:52:02 发布 · 288 阅读

0 ·

CC 4.0 BY-SA版权

C++算法专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了C++如何使用递归和循环两种方式实现树的前序、中序、后序和层序遍历。通过实例代码解析，帮助读者深入理解各种遍历策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<iostream>
#include<string>
#include<deque>
#include<queue>
#include<stack>
using namespace std;
struct TreeNode {
	string value_;
	TreeNode *left_;
	TreeNode *right_;
};

TreeNode * buildTreeNode(string in) {
	TreeNode * pNode = new TreeNode;
	pNode->value_ = in;
	pNode->left_ = nullptr;
	pNode->right_ = nullptr;
	return pNode;
}

void connectTreeNode(TreeNode *parents, TreeNode *left, TreeNode *right) {
	parents->left_ = left;
	parents->right_ = right;
}
//层序遍历，注意层序遍历要使用到队列，是先进先出的顺序
//void levelOrderTraverse(TreeNode * root) {
//	if (root == nullptr)
//		return;
//	queue<TreeNode *> a;
//	TreeNode * pNode;
//	a.push(root);
//	while (!a.empty()) {
//		pNode = a.front();
//		if (pNode->left_ != nullptr)
//			a.push(pNode->left_);
//		if (pNode->right_ != nullptr)
//			a.push(pNode->right_);
//		cout << pNode->value_ << " ";
//		a.pop();
//	}
//}


void levelOrderTraverse(TreeNode * root) {
	if (root == nullptr)
		return;
	deque<TreeNode *> a;
	a.push_back(root);
	TreeNode * pNode;
	while (!a.empty()) {
		pNode = a.front();
		if (pNode->left_ != nullptr)
			a.push_back(pNode->left_);
		if (pNode->right_ != nullptr)
			a.push_back(pNode->right_);
		cout << pNode->value_ << " ";
		a.pop_front();
	}
}
//基于递归的前序遍历
//void preOrderTraverse(TreeNode *root) {
//	if (root == nullptr)
//		return;
//	cout << root->value_ << " ";
//	preOrderTraverse(root->left_);
//	preOrderTraverse(root->right_);
//}
//基于循环的前序遍历
void preOrderTraverse(TreeNode *root) {
	if (root == nullptr)
		return;
	stack<TreeNode *> a;
	a.push(root);
	TreeNode * pNode;
	while (!a.empty()) {
		pNode = a.top();
		cout << pNode->value_ << " ";
		a.pop();
		if (pNode->right_ != nullptr)
			a.push(pNode->right_);
		if (pNode->left_ != nullptr)
			a.push(pNode->left_);
	}
}
//基于递归的中序遍历
//void midOrderTraverse(TreeNode *root) {
//	if (root == nullptr)
//		return;
//	midOrderTraverse(root->left_);
//	cout << root->value_ << " ";
//	midOrderTraverse(root->right_);
//}
//基于循环的中序遍历
void midOrderTraverse(TreeNode *root) {
	if (root == nullptr)
		return;
	stack<TreeNode *> a;
	a.push(root);
	TreeNode *pNode;
	int flag = 0;
	while (!a.empty()) {
		pNode = a.top();
		while (pNode->left_ != nullptr && flag != 1) {
			a.push(pNode->left_);
			pNode = pNode->left_;
		}
		cout << pNode->value_<<" ";
		a.pop();
		if (pNode->right_ != nullptr) {
			a.push(pNode->right_);
			flag = 0;
		}
		else
			flag = 1;
	}
}
//基于递归后序遍历
//void lastOrderTraverse(TreeNode * root) {
//	if (root == nullptr)
//		return;
//	lastOrderTraverse(root->left_);
//	lastOrderTraverse(root->right_);
//	cout << root->value_ << " ";
//}
//基于循环后序遍历
void lastOrderTraverse(TreeNode * root) {
	if (root == nullptr)
		return;
	stack<TreeNode *> a;
	a.push(root);
	TreeNode *cur=nullptr;
	TreeNode *pre=nullptr;
	while (!a.empty()) {
		cur = a.top();
		if ((cur->left_ == nullptr && cur->right_ == nullptr) || (pre != nullptr && (pre == cur->left_ || pre == cur->right_))) {
			cout << cur->value_ << " ";
			pre = cur;
			a.pop();
		}
		else {
			if (cur->right_ != nullptr)
				a.push(cur->right_);
			if (cur->left_ != nullptr)
				a.push(cur->left_);
		}

	}
}
int main() {
	TreeNode * a = buildTreeNode("A");
	TreeNode * b = buildTreeNode("B");
	TreeNode * c = buildTreeNode("C");
	TreeNode * d = buildTreeNode("D");
	TreeNode * e = buildTreeNode("E");
	TreeNode * f = buildTreeNode("F");
	TreeNode * g = buildTreeNode("G");
	TreeNode * h = buildTreeNode("H");
	TreeNode * i = buildTreeNode("I");
	connectTreeNode(a, b, c);
	connectTreeNode(b, d, nullptr);
	connectTreeNode(c, e, f);
	connectTreeNode(d, g, h);
	connectTreeNode(e, nullptr, i);
	connectTreeNode(f, nullptr, nullptr);
	connectTreeNode(g, nullptr, nullptr);
	connectTreeNode(h, nullptr, nullptr);
	connectTreeNode(i, nullptr, nullptr);
	levelOrderTraverse(a);
	cout << endl;
	preOrderTraverse(a);
	cout << endl;
	midOrderTraverse(a);
	cout << endl;
	lastOrderTraverse(a);

	return 0;
}