代码随想录算法训练营33期 第十四天| 递归遍历 （必须掌握）、 迭代遍历 、统一迭代

递归遍历

/*struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int v):val(v), left(nullptr), right(nullptr);
}*/
//前序遍历
class Solution {
public:
    void Traversal(TreeNode* cur, vector<int>& result){
        if (cur==nullptr) return ;
        result.push_back(cur->val);
        Traversal(cur->left, result);
        Traversal(cur->right, result);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root, result);
        
        return result;
    }
};

还是比较好理解的，递归终止条件为当前节点为空，即在某一个方向深度搜索到了最低点。

迭代遍历

//前序迭代
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root==nullptr) return result;
        st.push(root);

        while (!st.empty()){
            TreeNode* temp = st.top();
            st.pop();
            result.push_back(temp->val);
            if (temp->right) st.push(temp->right);
            if (temp->left) st.push(temp->left);
        }
        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* temp = st.top();
            st.pop();
            result.push_back(temp->val);
            if (temp->left) st.push(temp->left); //
            if (temp->right) st.push(temp->right); // 交换后出站顺序为中右左
        }
        reverse(result.begin(), result.end()); // 中右左反转之后变为左右中的后序遍历。
        return result;
    }
};

//中序迭代
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != nullptr || !st.empty()){//cur != nullptr排除了空树，!st.empty()保证遍历完全部栈
            if (cur != nullptr){
                st.push(cur);
                cur=cur->left;
            }
            else{
                cur = st.top();//回退到为null左结点的父节点
                st.pop();//父节点出栈，因为他没有左儿子，此时为栈顶元素。
                result.push_back(cur->val);
                cur=cur->right;
            }
        }
        return result;
    }
};

感觉中序的非递归方法有点像双指针，cur指向下一个节点，st.top()保存倒数第二个节点用于回退。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == nullptr) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if (node!=nullptr){
                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();// pop null
                node = st.top();
                result.push_back(node->val);//取出真实中间节点的值
                st.pop();
            }
        }
        return result;
    }
};

写的时候感觉还行，思路比较明确，但是不知道下次还能不能写出来了（）还记不记得了。