二叉树的前中后遍历-递归和非递归

Posted 2022-11-29 穿迷彩服的鲨鱼

// 二叉树的前中后遍历-递归和非递归.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

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

struct TreeNode

	int val;
	TreeNode* left;
	TreeNode* right;
;
/*前序遍历--递归*/
void PreoederDFS(TreeNode* root, vector<int>& result)

	if (root == nullptr)
	
		return;
	
	result.push_back(root->val);
	PreoederDFS(root->left, result);
	PreoederDFS(root->right, result);

vector<int> PreoederTraversalDfs(TreeNode* root)

	vector<int> result;
	if (root == nullptr)
	
		return result;
	
	PreoederDFS(root, result);
	return result;

/*前序遍历--栈*/
vector<int> PreoederTraversalStack(TreeNode* root)

	vector<int> result;
	if (root == nullptr)
	
		return result;
	
	TreeNode* tmpNode = nullptr;
	stack<TreeNode*> stackTreeode;
	stackTreeode.push(root);
	while (!stackTreeode.empty())
	
		tmpNode = stackTreeode.top();
		stackTreeode.pop();
		if (tmpNode != nullptr)
		
			result.push_back(tmpNode->val);
			stackTreeode.push(tmpNode->right);
			stackTreeode.push(tmpNode->left);
		
	
	return result;



/*中序遍历--递归*/
void InorderDFS(TreeNode* root, vector<int>& result)

	if (root == nullptr)return;
	InorderDFS(root->left, result);
	result.push_back(root->val);
	InorderDFS(root->right, result);

vector<int> InorderTraversalDfs(TreeNode* root)

	if (root == nullptr)return ;
	vector<int> result;
	InorderDFS(root, result);
	return result;

/*中序遍历--非递归(栈)*/
vector<int> InorderTraversal(TreeNode* root)

	if (root == nullptr)return;
	vector<int> result;
	stack<TreeNode*> stackTreeNode;
	while (root || !stackTreeNode.empty())
	
		while (root)
		
			stackTreeNode.push(root);
			root = root->left;
		
		root = stackTreeNode.top();
		stackTreeNode.pop();
		result.push_back(root->val);
		root = root->right;
	
	return result;

/*后续遍历--递归*/
void PostorderDfs(TreeNode* root, vector<int>& result)

	if (!root)return;
	PostorderDfs(root->left, result);
	PostorderDfs(root->right, result);
	result.push_back(root->val);

vector<int> PostorderTraversalDfs(TreeNode* root)

	if (!root)return;
	vector<int> result;
	PostorderDfs(root, result);
	return result;

/*后序遍历--栈*/
vector<int> PostorderTraversal(TreeNode* root)

	if (root == nullptr)return;
	vector<int> result;
	stack<TreeNode*> stackTreeNode;
	TreeNode* cur = root;
	TreeNode* last = nullptr;
	while (cur || !stackTreeNode.empty())
	
		while (cur)
		
			stackTreeNode.push(cur);
			cur = cur->left;
		
		TreeNode* top = stackTreeNode.top();
		if (top->right == nullptr)
		
			result.push_back(top->val);
			stackTreeNode.pop();
			last = top;
		
		else if (top->right == last)
		
			result.push_back(top->val);
			stackTreeNode.pop();
			top = last;
		
		else
		
			cur = top->right;
		
	
	return result;