代码随想录算法训练营第十四天|递归遍历、迭代遍历

递归遍历

前序遍历题目链接：https://leetcode.cn/problems/binary-tree-preorder-traversal/

中序遍历题目链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/

后序遍历题目链接：https://leetcode.cn/problems/binary-tree-postorder-traversal/

思路：

前序遍历：中左右

中序遍历：左中右

后序遍历：左右中

递归：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

代码：

• 前序遍历

/**
 * 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) {
        vector<int>result;
        preorder(root,result);
        return result;
    }

    void preorder(TreeNode* cur,vector<int>&vec)
    {
        // 确定终止条件
        if(cur==nullptr)
            return;

        // 确定单层递归逻辑
        vec.push_back(cur->val);
        preorder(cur->left,vec);
        preorder(cur->right,vec);
    }
    
};

• 中序遍历

/**
 * 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) {
        vector<int>result;
        inorder(root,result);
        return result;

    }

    void inorder(TreeNode *cur,vector<int>&vec)
    {
        if(cur==nullptr)
            return;

        inorder(cur->left,vec);
        vec.push_back(cur->val);
        inorder(cur->right,vec);
    }
};

• 后序遍历

/**
 * 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) {
        vector<int>result;
        postorder(root,result);
        return result;

    }

    void postorder(TreeNode *cur,vector<int>&vec)
    {
        if(cur==nullptr)
            return;

        postorder(cur->left,vec);
        postorder(cur->right,vec);
        vec.push_back(cur->val);
    }


};

总结

之前学习过递归遍历二叉树，现在当复习。

迭代遍历

前序遍历题目链接：https://leetcode.cn/problems/binary-tree-preorder-traversal/

中序遍历题目链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/

后序遍历题目链接：https://leetcode.cn/problems/binary-tree-postorder-traversal/

思路：

前序遍历：中左右

中序遍历：左中右

后序遍历：左右中

代码：

• 前序遍历

/**
 * 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) {
        vector<int>result;
        stack<TreeNode*>st;

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

        st.push(root);

        // 先存入右后存入左是因为栈是先进后出
        while(!st.empty())
        {
            TreeNode *node = st.top();
            st.pop();
            // 中
            result.push_back(node->val);

            // 右
            if(node->right)
                st.push(node->right);

            // 左
            if(node->left)
                st.push(node->left);
        }

        return result;

    }
};

• 中序遍历

/**
 * 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) {
        vector<int>result;
        stack<TreeNode*>st;
        if(root == nullptr)
            return result;
        
        TreeNode *cur = root;
        while(!st.empty()||cur!=nullptr)
        {
            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;

    }
};

• 后序遍历

/**
 * 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) {
        vector<int>result;
        stack<TreeNode*>st;

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

        st.push(root);

        while(!st.empty())
        {
            TreeNode *node = st.top();
            st.pop();
            // 中
            result.push_back(node->val);

            // 左
            if(node->left)
                st.push(node->left);

            // 右
            if(node->right)
                st.push(node->right);
        }

        // 中右左----左右中
        reverse(result.begin(),result.end());
        return result;

    }
};

总结

第一次学习迭代遍历，即使先看完题解，自己在写的过程中还是不同清楚逻辑，模拟了一遍才知道要怎么写代码。

今日总结：

需要多加练习，统一迭代的方法看代码可以理解，但是不明白为什么要这么做。