foreword
There are usually three methods for traversing a binary tree: iterative method, recursive method, and Morris algorithm.
preorder traversal
LeetCode 144. Preorder traversal of binary tree https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
Method 1: Iterative method
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
stack<TreeNode *> stk;
stk.emplace(root);
while (!stk.empty()) {
TreeNode *node = stk.top();
stk.pop();
ans.emplace_back(node->val);
if (node->right) {
stk.emplace(node->right);
}
if (node->left) {
stk.emplace(node->left);
}
}
return ans;
}
}; // 迭代法
Method 2: Recursive method
class Solution {
private:
void dfs(TreeNode *root, vector<int>& ans) {
if (!root) {
return;
}
ans.emplace_back(root->val);
dfs(root->left, ans);
dfs(root->right, ans);
}
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
dfs(root, ans);
return ans;
}
}; // 递归法
Method 3: Morris Algorithm
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
while (root) {
if (!root->left) {
ans.emplace_back(root->val);
root = root->right;
}
else {
TreeNode *node = root->left;
while (node->right && node->right != root) {
node = node->right;
}
if (!node->right) {
ans.emplace_back(root->val);
node->right = root;
root = root->left;
}
else {
node->right = nullptr;
root = root->right;
}
}
}
return ans;
}
}; // Morris算法
Inorder traversal
LeetCode 94. Inorder traversal of a binary tree https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
Method 1: Iterative method
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
stack<TreeNode*> stk;
TreeNode *node = root;
while (!stk.empty() || node) {
while (node) {
stk.emplace(node);
node = node->left;
}
node = stk.top();
stk.pop();
ans.emplace_back(node->val);
node = node->right;
}
return ans;
}
}; // 迭代法
Method 2: Recursive method
class Solution {
private:
void dfs(TreeNode *root, vector<int>& ans) {
if (!root) {
return;
}
dfs(root->left, ans);
ans.emplace_back(root->val);
dfs(root->right, ans);
}
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
dfs(root, ans);
return ans;
}
}; // 递归法
Method 3: Morris Algorithm
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
while (root) {
if (!root->left) {
ans.emplace_back(root->val);
root = root->right;
}
else {
TreeNode *node = root->left;
while (node->right && node->right != root) {
node = node->right;
}
if (!node->right) {
node->right = root;
root = root->left;
}
else {
ans.emplace_back(root->val);
node->right = nullptr;
root = root->right;
}
}
}
return ans;
}
}; // Morris算法
post order traversal
LeetCode 145. Postorder traversal of binary tree https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
Method 1: Iterative method
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
stack<TreeNode*> stk;
stk.emplace(root);
while (!stk.empty()) {
TreeNode *node = stk.top();
stk.pop();
ans.emplace_back(node->val);
if (node->left) {
stk.emplace(node->left);
}
if (node->right) {
stk.emplace(node->right);
}
}
reverse(ans.begin(), ans.end());
return ans;
}
}; // 迭代法
Method 2: Recursive method
class Solution {
private:
void dfs(TreeNode *root, vector<int>& ans) {
if (!root) {
return;
}
dfs(root->left, ans);
dfs(root->right, ans);
ans.emplace_back(root->val);
}
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
dfs(root, ans);
return ans;
}
}; // 递归法
Method 3: Morris Algorithm
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) {
return ans;
}
while (root) {
if (!root->right) {
ans.emplace_back(root->val);
root = root->left;
}
else {
TreeNode *node = root->right;
while (node->left && node->left != root) {
node = node->left;
}
if (!node->left) {
ans.emplace_back(root->val);
node->left = root;
root = root->right;
}
else {
node->left = nullptr;
root = root->left;
}
}
}
reverse(ans.begin(), ans.end());
return ans;
}
}; // Morris算法
sequence traversal
LeetCode 102. Binary tree level order traversal https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
Method 1: Iterative method
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
if (!root) {
return ans;
}
queue<TreeNode*> q;
q.emplace(root);
while (!q.empty()) {
int s = q.size();
vector<int> t;
for (int i = 0; i < s; ++i) {
TreeNode *node = q.front();
q.pop();
t.emplace_back(node->val);
if (node->left) {
q.emplace(node->left);
}
if (node->right) {
q.emplace(node->right);
}
}
ans.emplace_back(t);
}
return ans;
}
}; // 迭代法
Method 2: Recursive method
class Solution {
private:
void dfs(TreeNode *root, vector<vector<int>>& ans, int depth) {
if (!root) {
return;
}
if (ans.size() >= depth + 1) {
ans[depth].emplace_back(root->val);
}
else {
ans.emplace_back(vector<int> {
root->val});
}
dfs(root->left, ans, depth + 1);
dfs(root->right, ans, depth + 1);
}
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
dfs(root, ans, 0);
return ans;
}
}; // 递归法
I am just a programming novice. I write a blog for the purpose of summarizing and communicating. I implore everyone to criticize and correct me!