LeetCode：二叉树的中序遍历（递归与非递归法）

最新推荐文章于 2025-04-04 19:08:27 发布

嘉木空青

最新推荐文章于 2025-04-04 19:08:27 发布

阅读量1k

点赞数

分类专栏： C/C++ 基础算法

本文链接：https://blog.youkuaiyun.com/Doutd_y/article/details/82706734

版权

C/C++ 同时被 2 个专栏收录

73 篇文章

订阅专栏

基础算法

24 篇文章

订阅专栏

二叉树结点类：

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x): val(x), left(NULL), right(NULL) {}
};

递归法：

class Solution{

public:

    void inOrder(TreeNode *root, vector<int> &vec)
    {
        if(root != NULL)
        {
            inOrder(root->left, vec);

            vec.push_back(root->val);
            
            inOrder(root->right, vec);        
        }
    }

    vector<int> inorderTraversal(TreeNode *root)
    {
        vector<int> vec;
        inOrder(root, vec);
        return vec;
    }

非递归法：

借助栈来实现中序遍历（左根右）：

代码1：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if(root == NULL)
            return res;
        stack<TreeNode *> st;

        TreeNode *p = root;

        while(p || st.size())
        {
            if(p)
            {
                st.push(p);
                p = p->left;
            }
            else
            {
                 p = st.top();
                 st.pop();
                 res.push_back(p);
                 p = p->right;  
            }
        }        

        return res;
    }
};

代码2：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if(root == NULL)
            return res;
        stack<TreeNode *> st;

        TreeNode *p = root;
        while(p || st.size())
        {
            while(p)
            {
                st.push(p);
                p = p->left;
            }
            if(st.size())
            {
                 p = st.top();
                 st.pop();
                 res.push_back(p);
                 p = p->right;  
            }
        }        

        return res;
    }
};

代码3：(有待验证)

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if(root == NULL)
            return res;
        stack<TreeNode *> st;

        TreeNode *p = root;
        st.push(p);
        while(p || st.size())
        {
            while(p->left)
            {
                p = p->left;
                st.push(p);
            }
            if(st.size())
            {
                 p = st.top();
                 st.pop();
                 res.push_back(p);
                 p = p->right;  
            }
        }        

        return res;
    }
};