代码随想录训练营第十四天｜递归遍历，迭代遍历，统一迭代

ababababyyyy

已于 2023-02-16 11:54:49 修改

阅读量88

点赞数

文章标签： c++ Powered by 金山文档

于 2023-02-14 20:54:54 首次发布

本文链接：https://blog.csdn.net/ababababyyyy/article/details/129029525

版权

本文介绍了如何使用递归和迭代方法来实现二叉树的前序、中序和后序遍历。在递归方法中，分别对根节点、左子树和右子树进行操作。而在迭代方法中，利用栈来辅助完成遍历，对于前序和中序遍历，需要处理空树和非空树的情况，后序遍历则需要在遍历完成后反转结果。所有代码均以C++编写，适用于LeetCode等在线编程平台。

摘要由CSDN通过智能技术生成

递归遍历

前序遍历：

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

代码：

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

注意：Traversal函数中的第二个参数是vector<int>& res，必须含有地址字符&，这样才能传入到数组result中，否则没有办法传入进去。

中序遍历：

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

代码：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root,result);
        return result;
    }
    void Traversal(TreeNode* root,vector<int>& res)
    {
        if(root == nullptr)
            return;
        Traversal(root->left,res);
        res.push_back(root->val);
        Traversal(root->right,res);
    }
};

后续遍历：

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

代码：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root,result);
        return result;
    }
    void Traversal(TreeNode* root,vector<int>& res)
    {
        if(root == nullptr)
            return;
        Traversal(root->left,res);
        Traversal(root->right,res);
        res.push_back(root->val);
    }
};

迭代遍历：

前序遍历：

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

代码：

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

用的是栈

中序遍历：

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

代码：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode* dp = root;
        while(!st.empty() || dp)
        {
            if(dp)
            {
                st.push(dp);
                dp = dp->left;
            }else
            {
                TreeNode* tmp = st.top();
                st.pop();
                result.push_back(tmp->val);
                dp = tmp->right;
            }
        }
        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* tmp = st.top();
            result.push_back(tmp->val);
            st.pop();
            if(tmp->left)
            {
                st.push(tmp->left);
            }
            if(tmp->right)
            {
                st.push(tmp->right);
            }
        }
        reverse(result.begin(), result.end());
        return result;
    }
    
};

为啥不reverse，直接前面反过来会超时啊？

统一迭代

中序遍历：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root == nullptr)
            return result;
        st.push(root);
        while(!st.empty())
        {
            TreeNode* dp = st.top();
            st.pop();
            if(dp != nullptr)
            {
                if(dp->right)
                    st.push(dp->right);
                st.push(dp);
                st.push(nullptr);
                if(dp->left)
                    st.push(dp->left);
            }else
            {
                dp = st.top();
                st.pop();
                result.push_back(dp->val);
            }
        }
        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* dp = st.top();
            st.pop();
            if(dp)
            {
                if(dp->right)
                    st.push(dp->right);
                if(dp->left)
                    st.push(dp->left);
                st.push(dp);
                st.push(nullptr);
            }else
            {
                dp = st.top();
                st.pop();
                result.push_back(dp->val);
            }
        }
        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* dp = st.top();
            st.pop();
            if(dp)
            {
                st.push(dp);
                st.push(nullptr);
                if(dp->right)
                    st.push(dp->right);
                if(dp->left)
                    st.push(dp->left);
            }else
            {
                dp = st.top();
                st.pop();
                result.push_back(dp->val);
            }
        }
        return result;
    }
};