代码随想录算法训练营第十二天打卡

1.二叉树的递归遍历

前序遍历代码如下：

class Solution { //前序遍历的顺序是 中左右
public:
    void traversal(TreeNode* curr, vector<int>& nums) {
        if (curr == nullptr) {
            return;
        }
        nums.push_back(curr->val); //中
        traversal(curr->left, nums); //左
        traversal(curr->right, nums); //右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        traversal(root, ans);
        return ans;
    }
};

中序遍历代码如下：

class Solution { //中序遍历的顺序是 左中右
public:
    void traversal(TreeNode* curr, vector<int>& nums) {
        if (curr == nullptr) {
            return;
        }
        traversal(curr->left, nums); //左
        nums.push_back(curr->val); //中
        traversal(curr->right, nums); //右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        traversal(root, ans);
        return ans;
    }
};

后序遍历代码如下：

class Solution { //后序遍历的顺序是 左右中
public:
    void traversal(TreeNode* curr, vector<int>& nums) {
        if (curr == nullptr) {
            return;
        }
        traversal(curr->left, nums); //左
        traversal(curr->right, nums); //右
        nums.push_back(curr->val); //中
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        traversal(root, ans);
        return ans;
    }
};

2.二叉树的迭代遍历

前序遍历代码如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        if (root == nullptr) {
            return ans;
        }
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top(); //中
            st.pop();
            ans.push_back(node->val);
            if (node->right) { //左
                st.push(node->right);
            }
            if (node->left) { //右
                st.push(node->left);
            }
        }
        return ans;
    }
};

后序遍历代码如下：（与前序遍历高度相似）

class Solution { //后序遍历的顺序是 左右中
public:
    vector<int> postorderTraversal(TreeNode* root) { //方法二：遍历
        vector<int> ans;
        stack<TreeNode*> st;
        if (root == nullptr) {
            return ans;
        }
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            ans.push_back(node->val); //中
            if (node->left) {
                st.push(node->left); //右
            }
            if (node->right) {
                st.push(node->right); //左
            }
        }
        reverse(ans.begin(), ans.end()); //反转，顺序变成 左右中
        return ans;
    }
};

中序遍历：（与前面两个不太一样）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> st;
        TreeNode* curr = root;
        while (curr || !st.empty()) {
            while (curr) {
                st.push(curr);
                curr = curr->left;
            }
            curr = st.top();
            st.pop();
            ans.push_back(curr->val);
            curr = curr->right;
        }
        return ans;
    }
};

3.二叉树的统一迭代

以中序遍历为例，代码如下：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

今毕。