C++实现二叉树的遍历（前中后递归与非递归）

C++实现二叉树的遍历（前中后 递归与非递归）

---

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

//二叉树结构体定义
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	//TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
	TreeNode(int x) { //树节点的构造函数
		val = x;
		left = nullptr;
		right = nullptr;
	}
};

//前中后序遍历 递归实现
void preOrderRec(TreeNode* root) {

	if (root == nullptr) return;

	cout << root->val << " "; // 前中后序遍历，打印位置不同

	if (root->left)
		preOrderRec(root->left);
	//cout<<root->val<<" "; //中序遍历
	if (root->right)
		preOrderRec(root->right);
	//cout<<root->val<<" "; //后序遍历
	return;
}

//前序遍历 非递归实现 利用栈
void preOrder(TreeNode* root) {

	if (root == nullptr) return;

	stack<TreeNode*> s;
	s.push(root);
	TreeNode* p = s.top();

	while (!s.empty()) {
		
		s.pop();
		while (p) {
			cout << p->val << " ";
			if (p->right) s.push(p->right);
			p = p->left;
		}

		if(s.size() != 0)
			p = s.top();

	}

	return;
}

//中序遍历 非递归实现 利用栈
void midOrder(TreeNode* root) {

	if (root == nullptr) return;

	stack<TreeNode*> s;
	TreeNode* p = root;

	while (!s.empty() || p) {

		while (p) {
			s.push(p);
			p = p->left;
		}

		p = s.top();
		cout << p->val << " ";
		s.pop();
		p = p->right;
	}

	return;
}

//后序遍历 非递归实现 利用栈
void postOrder(TreeNode* root) {

	stack<TreeNode*> s;
	TreeNode* p = root;
	s.push(p);
	TreeNode* pre = nullptr;

	while (!s.empty()) {

		TreeNode* cur = s.top();
		if ((cur->left == nullptr && cur->right == nullptr) || (pre != nullptr && (pre == cur->left || pre == cur->right))) {
			cout << cur->val <<" ";
			pre = cur;
			s.pop();
		}
		else {
			if (cur->right != nullptr) {
				s.push(cur->right);
			}
			if (cur->left != nullptr) {
				s.push(cur->left);
			}
		}

	}

	return;
}

//利用队列实现层序遍历来打印二叉树
void printTreeNode(TreeNode* root) {

	if (root == nullptr) return;

	queue<TreeNode*> s;
	s.push(root);

	while (!s.empty())
	{
		TreeNode* p = s.front();
		s.pop();

		cout<<p->val<<" ";

		if (p->left != nullptr)
			s.push(p->left);
		if (p->right != nullptr)
			s.push(p->right);
	}

	cout << endl;
	return;
}

int main() {

	TreeNode* node1 = new TreeNode(1);
	TreeNode* node2 = new TreeNode(2);
	TreeNode* node3 = new TreeNode(3);
	TreeNode* node4 = new TreeNode(4);
	TreeNode* node5 = new TreeNode(5);

	node1->left = node2;
	node1->right = node3;
	node2->left = node4;
	node2->right = node5;
	
	cout << "层序遍历打印二叉树！" << endl;
	printTreeNode(node1);
	cout << endl;	

	cout << "非递归前序打印二叉树！" << endl;
	preOrder(node1);
	cout << endl;

	cout << "非递归中序打印二叉树！" << endl;
	midOrder(node1);
	cout << endl;

	cout << "非递归后序打印二叉树！" << endl;
	postOrder(node1);
	cout << endl;

	return 0;
}

输出结果：

层序遍历打印二叉树！
1 2 3 4 5
非递归前序打印二叉树！
1 2 4 5 3
非递归中序打印二叉树！
4 2 5 1 3
非递归后序打印二叉树！
4 5 2 3 1