324-Leetcode 二叉树的前序遍历

方法一：递归

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 helper(TreeNode* root, vector<int>& ve)
	{
		if (root == nullptr) return;
		ve.push_back(root->val);
		if (root->left) helper(root->left, std::ref(ve));
		if (root->right) helper(root->right, std::ref(ve));
	}
	vector<int> preorderTraversal(TreeNode* root) 
	{
		vector<int> ve;
		helper(root, std::ref(ve));
		return ve;
	}
};
int main()
{
	Solution A;
	TreeNode* t = new TreeNode(2, nullptr, new TreeNode(3, new TreeNode(4, nullptr, nullptr), nullptr));
	vector<int> ve = A.preorderTraversal(t);
	return 0;
}

时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次

空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为 O(logn)，最坏情况下树呈现链状，为 O(n)

方法二：迭代

迭代和递归的区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显式地将这个栈模拟出来，其余的实现与细节都相同

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:
	vector<int> preorderTraversal(TreeNode* root) 
	{
		vector<int> ve;
		if (root == nullptr) return ve;
		TreeNode* node = root;
		stack<TreeNode*> st;
		while (!st.empty() || node != nullptr)
		{
			while (node != nullptr)
			{
				ve.push_back(node->val);
				st.emplace(node);
				node = node->left;
			}
			node = st.top(); st.pop();
			node = node->right;
		}
		return ve;
	}
};
int main()
{
	Solution A;
	TreeNode* t = new TreeNode(2, nullptr, new TreeNode(3, new TreeNode(4, nullptr, nullptr), nullptr));
	vector<int> ve = A.preorderTraversal(t);
	return 0;
}

时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次。

空间复杂度：O(n)，为迭代过程中显式栈的开销，平均情况下为 O(logn)，最坏情况下树呈现链状，为 O(n)

方法三：Morris 遍历

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:
	vector<int> preorderTraversal(TreeNode* root) 
	{
		vector<int> ve;
		if (root == nullptr) return ve;
		while (root != nullptr)
		{
			if (root->left == nullptr)
			{
				ve.emplace_back(root->val);
				root = root->right;
			}
			else
			{
				TreeNode* prodecessor = root->left;
				while (prodecessor->right != nullptr && prodecessor->right != root)
				{
					prodecessor = prodecessor->right;
				}
				if (prodecessor->right == nullptr)
				{
					ve.emplace_back(root->val);
					prodecessor->right = root;
					root = root->left;
					continue;
				}
				else
				{
					prodecessor->right = nullptr;
					root = root->right;
				}
			}
		}
		return ve;
	}
};
int main()
{
	Solution A;
	TreeNode* t = new TreeNode(2, nullptr, new TreeNode(3, new TreeNode(4, nullptr, nullptr), nullptr));
	vector<int> ve = A.preorderTraversal(t);
	return 0;
}

时间复杂度：O(n)，其中 n 是二叉树的节点数。没有左子树的节点只被访问一次，有左子树的节点被访问两次

空间复杂度：O(1)，只操作已经存在的指针（树的空闲指针），因此只需要常数的额外空间