代码随想录算法训练营第14天 ｜ 理论基础 递归遍历 迭代遍历 统一迭代

144 preorder

/* 递归遍历
    class Solution {
    void Traversal(TreeNode* root, vector<int> &res){
        if (root == nullptr) {
            return;
        }
        res.push_back(root->val);
        Traversal(root->left, res);
        Traversal(root->right, res);
        return;
    }
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
}; */

//迭代遍历， 用栈
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stack;

        if (root == NULL) return res;

        stack.push(root);
        while (!stack.empty()) {
            TreeNode* curr = stack.top();
            stack.pop();
            res.push_back(curr->val);
            if (curr->right!= NULL) stack.push(curr->right);
            if (curr->left != NULL) stack.push(curr->left);
        }
        return res;
    }
};

迭代遍历要难一点

1.得想一下什么时候push_back到vector

2. 先放右孩子 

先画图想清楚入栈出栈的顺序 已经什么时候push到vector。

while的条件是stack not empty 即每次pop一个root 并处理。

94 inorder

/* 递归遍历
    class Solution {
    void traversal(TreeNode* root, vector<int>& res){
        if (root == nullptr) return;
        traversal(root->left, res);
        res.push_back(root->val);
        traversal(root->right, res);
    }
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
}; */

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

迭代遍历难

思路：访问顺序（中左右）处理顺序（左中右）需要一个curr指针指向访问的节点

从root开始 入栈，只要有左孩子，左孩子入栈，curr=curr->left. 一直到左孩子为空。（否则一直在while里面）

如果发现无左孩子，指针指向最后入栈的，处理它（此时看作正在处理左or中），且考虑右边，curr = curr->right. 表示下一个要处理的是右边。

while终止条件：stack为空 还有一个curr!=NULL只是为了一开始进while。

写的还是不是很清楚，需要画图举例结合理解。

145 postorder

cr to 代码随想录 

/* //递归遍历 
class Solution {
    void Traversal(TreeNode* root, vector<int> &res){
        if (root == nullptr) {
            return;
        }
        Traversal(root->left, res);
        Traversal(root->right, res);
        res.push_back(root->val);
        return;
    }
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
}; */
//迭代遍历
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        stack<TreeNode*> reverse;

        if (root == nullptr) return res;

        st.push(root);
        while (!st.empty()) {
            TreeNode* curr = st.top();
            st.pop();
            reverse.push(curr);
            if (curr->left != nullptr) st.push(curr->left);
            if (curr->right != nullptr) st.push(curr->right);
        }

        while (!reverse.empty()) {
            TreeNode* curr = reverse.top();
            res.push_back(curr->val);
            reverse.pop();
        }

        return res;
    }
};