代码随想录算法训练营第14天|144. 二叉树的前序遍历，145. 二叉树的后序遍历，94. 二叉树的中序遍历

144. 二叉树的前序遍历

题目链接：144. 二叉树的前序遍历，难度：简单
【实现代码】

//递归遍历
/**
 * Definition for a binary tree node.
 * 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>& vec) {
        if (cur == nullptr) {
            return ;
        }
        vec.push_back(cur->val);
        traversal(cur->left, vec);
        traversal(cur->right, vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};
//迭代遍历
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if (root == nullptr) {
            return result;
        }
        stack<TreeNode*> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode* tmp = st.top();
            st.pop();
            result.push_back(tmp->val);
            if (tmp->right != nullptr) {
                st.push(tmp->right);
            }
            if (tmp->left != nullptr) {
                st.push(tmp->left);
            }
        }
        return result;
    }
};
//统一迭代
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root) {
            st.push(root);
        }
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();
                if(node->right) {
                    st.push(node->right);
                }
                if (node->left) {
                    st.push(node->left);
                }
                st.push(node);
                st.push(nullptr);                
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

145. 二叉树的后序遍历

题目链接：145. 二叉树的后序遍历，难度：简单
【实现代码】

//递归遍历
/**
 * Definition for a binary tree node.
 * 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>& vec) {
        if (cur == nullptr) {
            return ;
        }
        traversal(cur->left, vec);
        traversal(cur->right, vec);
        vec.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) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root == nullptr) {
            return result;
        }
        st.push(root);        
        while (!st.empty()) {
            TreeNode* tmp = st.top();
            st.pop();
            result.push_back(tmp->val);
            if (tmp->left != nullptr) {
                st.push(tmp->left);
            }
            if (tmp->right != nullptr) {
                st.push(tmp->right);
            }
        }
        reverse(result.begin(), result.end());
        return result;
    }
};
//统一迭代
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root) {
            st.push(root);
        }
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();
                st.push(node);
                st.push(nullptr);
                if (node->right) {
                    st.push(node->right);
                }
                if (node->left) {
                    st.push(node->left);
                }
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

94. 二叉树的中序遍历

题目链接：94. 二叉树的中序遍历，难度：简单
【实现代码】

//递归遍历
/**
 * Definition for a binary tree node.
 * 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>& vec) {
        if (cur == nullptr) {
            return ;
        }
        vec.push_back(cur->val);
        traversal(cur->left, vec);
        traversal(cur->right, vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

//迭代遍历
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur != nullptr || !st.empty()) {
            if (cur != nullptr) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};
//统一迭代
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root) {
            st.push(root);
        }
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();
                if (node->right) {
                    st.push(node->right);
                }
                st.push(node);
                st.push(nullptr);
                if (node->left) {
                    st.push(node->left);
                }
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

【总结】

【递归法】在递归法中，按照遍历的顺序进行递归或者放进结果集中，即可统一写法；
【迭代法】在迭代法中，因为中序的访问节点和放进结果集中的节点不同，即需要一直找到左节点，当遇到中间节点时需要再往下找一层，当遇到空节点时才开始存放结果，所以与前序和后序的写法不同；
【统一迭代法】在统一迭代法中，当插入中间节点时，只需再其后插入一个空节点，即使用空节点作为标记。这种方法是按照遍历的倒序把节点放入栈中，碰到空节点时就弹栈，否则就继续压栈。如果没有加入空节点作为标记，则会当成左节点或者右节点继续把下层节点压栈，陷入死循环；加入空节点，多了一次弹栈操作，即弹出了中间节点，从而可以向上层返回。