代码随想录_二叉树_leetcde 144 94 145

题目

144. 二叉树的前序遍历

94. 二叉树的中序遍历

145. 二叉树的后序遍历

代码

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

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode() : val(0), left(nullptr), right(nullptr) {}
	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
};

// 前序遍历
// 根左右

// 递归法
class Solution {
public:
	void traversal(TreeNode* cur, vector<int>& result)
	{
		if (cur == nullptr)
		{
			return;
		}
		result.push_back(cur->val);
		traversal(cur->left, result);
		traversal(cur->right, result);
	}

	vector<int> preorderTraversal(TreeNode* root) {
		vector<int> result;
		traversal(root, result);
		return result;
	}
};

// 迭代法
// 要保证输出顺序是 根左右
// 我们可以使用栈结构来保存结点
// 弹出栈顶结点后 右子树和左子树依次入栈
// 这样可以保证 弹出顺序
class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		if (root == nullptr)
		{
			return {};
		}
		vector<int> result;
		stack<TreeNode*> treeSta;
		treeSta.push(root);
		TreeNode* cur;
		while (!treeSta.empty())
		{
			cur = treeSta.top();
			treeSta.pop();
			result.push_back(cur->val);
			if (cur->right != nullptr)
			{
				treeSta.push(cur->right);
			}
			if (cur->left != nullptr)
			{
				treeSta.push(cur->left);
			}
		}
		return result;
	}
};


// 中序遍历
// 左根右

// 递归法
class Solution {
public:
	void traversal(TreeNode* cur, vector<int>& result)
	{
		if (cur == nullptr)
		{
			return;
		}
		traversal(cur->left, result);
		result.push_back(cur->val);
		traversal(cur->right, result);
	}

	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> result;
		traversal(root, result);
		return result;
	}
};


// 迭代法
// 保证左根右
// 使用栈的数据结构
// 一直遍历左子树直到为空
// 弹出栈顶元素 
// 如果当前结点存在右子树则右子树入栈 
// 并把当前结点更新为右子树继续循环
class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root) {
		if (root == nullptr)
		{
			return {};
		}
		vector<int> result;
		stack<TreeNode*> treeSta;
		TreeNode* cur = root;
		while (!treeSta.empty() || cur != nullptr)
		{
			while (cur != nullptr)
			{
				treeSta.push(cur);
				cur = cur->left;
			}
			cur = treeSta.top();
			treeSta.pop();
			result.push_back(cur->val);
			cur = cur->right;
		}
		return result;
	}
};



// 后序遍历
// 左右根

// 递归法
class Solution {
public:
	void traversal(TreeNode* cur, vector<int>& result)
	{
		if (cur == nullptr)
		{
			return;
		}
		traversal(cur->left, result);
		traversal(cur->right, result);
		result.push_back(cur->val);
	}

	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> result;
		traversal(root, result);
		return result;
	}
};


//迭代法
// 继续使用栈的数据结构
// 但是需要一个标志位 来确认这个节点是否被访问过 
// 根节点入栈
// 然后取出栈顶元素   
// 如果被访问过表明 这个节点的左右子树已经入栈了 可以出栈了
// 如果未被访问过 则现将当前结点入栈 然后依次将 右子树左子树入栈

class Solution {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		if (root == nullptr)
		{
			return {};
		}
		vector<int> result;
		stack<pair<TreeNode*, bool>> treeSta;
		treeSta.push({root, false});
		TreeNode* cur;
		bool flag;
		while (!treeSta.empty())
		{
			auto iter = treeSta.top();
			cur = iter.first;
			flag = iter.second;
			treeSta.pop();
			if (flag)
			{
				//如果之前已经访问过 那直接出栈即可
				result.push_back(cur->val);
			}
			else
			{
				treeSta.push({ cur, true });
				if (cur->right != nullptr)
				{
					treeSta.push({ cur->right, false });
				}
				if (cur->left != nullptr)
				{
					treeSta.push({ cur->left, false });
				}
			}
		}
		return result;
	}
};