prefacio
Por lo general, existen tres métodos para atravesar un árbol binario: el método iterativo, el método recursivo y el algoritmo de Morris.
recorrido de pedido anticipado
LeetCode 144. Pedido previo de recorrido del árbol binario https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
Método 1: método iterativo
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;
}
}; // 迭代法
Método 2: método recursivo
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;
}
}; // 递归法
Método 3: Algoritmo de Morris
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算法
Recorrido en orden
LeetCode 94. Recorrido en orden de un árbol binario https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
Método 1: método iterativo
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;
}
}; // 迭代法
Método 2: método recursivo
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;
}
}; // 递归法
Método 3: Algoritmo de Morris
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算法
traspaso de pedidos posteriores
LeetCode 145. Recorrido posterior al pedido del árbol binario https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
Método 1: método iterativo
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;
}
}; // 迭代法
Método 2: método recursivo
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;
}
}; // 递归法
Método 3: Algoritmo de Morris
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算法
recorrido de secuencia
LeetCode 102. Recorrido de orden de nivel de árbol binario https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
Método 1: método iterativo
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;
}
}; // 迭代法
Método 2: método recursivo
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;
}
}; // 递归法
Solo soy un novato en programación. Escribo un blog con el propósito de resumir y comunicar. ¡Imploro a todos que me critiquen y corrijan!