代码随想录算法训练营第十四天 | LeetCode 94、144、145

---

前言

LeetCode题目：LeetCode 94、144、145
Takeaway：今天的三道题，如果只是用递归实现，那么难度其实很低，但是重要的是学会使用迭代实现和统一的迭代实现，即：标记法。

---

一、递归法实现

最简单易懂的实现方法，递归出口就是走到头(NULL)。三个顺序的差别只有递归时赋值，左，右的先后顺序，这里只列出前序，因为没什么好说的。

/**
 * 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:
    vector<int> ans;

    void DG(TreeNode* root){
        if(root == nullptr){
            return;
        }
        ans.push_back(root->val);
        DG(root->left);
        DG(root->right);
    }

    vector<int> preorderTraversal(TreeNode* root) {
        DG(root);
        return ans;
    }
};

---

二、迭代法实现

用栈来实现对二叉树的三种不同顺序访问，易于理解但是要注意顺序是反着来的。

1、前序遍历

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> stack_pre;
        stack_pre.push(root);
        vector<int> ans;

        if(root == nullptr){
            return ans;
        }

        while(!stack_pre.empty()){
            TreeNode *cur = stack_pre.top();
            ans.push_back(cur->val);
            stack_pre.pop();
            if(cur->right != nullptr){
                stack_pre.push(cur->right);
            }
            if(cur->left != nullptr){
                stack_pre.push(cur->left);
            }
        }

        return ans;
    }
};

2、中序遍历

这里注意，和前序实现不是简单修改就可以实现的，因为前序的时候可以同时探索+处理当前节点，中序遍历方式不行，就只能用指针记录要处理的节点。

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> stack_mid;
        vector<int> ans;

        if(root == nullptr){
            return ans;
        }

        TreeNode *cur = root;
        while(cur!=NULL || !stack_mid.empty()){
            if(cur!=NULL){
                stack_mid.push(cur);
                cur = cur->left;
            }else{
                cur = stack_mid.top();
                stack_mid.pop();
                ans.push_back(cur->val);
                cur = cur->right;
            }
        }

        return ans;
    }
};

3、后序遍历

只要反着来(中右左)遍历，把得到的结果用reverse()反转一下，就是正确答案了。

/**
 * 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:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> stack_end;
        stack_end.push(root);
        vector<int> ans;

        if(root == nullptr){
            return ans;
        }

        while(!stack_end.empty()){
            TreeNode *cur = stack_end.top();
            stack_end.pop();

            ans.push_back(cur->val);
            
            if(cur->left != nullptr){
                stack_end.push(cur->left);
            }

            if(cur->right != nullptr){
                stack_end.push(cur->right);
            }

            
        }


        reverse(ans.begin(),ans.end());

        return ans;
    }
};

---

三、统一的迭代法实现——标记法

与 二 不同，为了让二叉树的不同的顺序遍历的迭代实现可以通过简单修改就能彼此转换，我们采用标记法来实现，也就是当我们放入的元素要被处理时，额外加入一个NULL为标记，表示可以处理这个元素了，这样就可以做到同时探索+处理元素。这里只写前序，因为中后顺序和前序改动很小。

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> stack_mid;
        vector<int> ans;

        if(root == NULL){
            return ans;
        }
        
        stack_mid.push(root);
        while(!stack_mid.empty()){
            if(stack_mid.top() != NULL){
                TreeNode* cur = stack_mid.top();
                stack_mid.pop();

                if(cur->right != NULL){
                    stack_mid.push(cur->right);
                }

                if(cur->left != NULL){
                    stack_mid.push(cur->left);
                }

                stack_mid.push(cur);
                stack_mid.push(NULL);
            }else{
                stack_mid.pop();
                ans.push_back(stack_mid.top()->val);
                stack_mid.pop();
            }
        }

        return ans;
    }
};

---

总结

今天的三道题，如果只是用递归实现，那么难度其实很低，但是重要的是学会使用迭代实现和统一的迭代实现，即：标记法。