二叉树递归与迭代遍历

最新推荐文章于 2024-07-20 11:22:21 发布

JachinYang

最新推荐文章于 2024-07-20 11:22:21 发布

阅读量108

点赞数

分类专栏：数据结构文章标签：二叉树数据结构

本文链接：https://blog.csdn.net/JachinYang/article/details/117427681

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

节点定义：

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

1、递归解法

前序遍历

class soulution
{
    public:
        //确定递归函数的参数和返回值
        void Qtraversal(TreeNode* cur, vector<int>& vec)  //前序遍历
        {
            //确定终止条件
            if(cur == NULL) return;
            //确定单层递归的逻辑
            vec.push_back(cur->val);
            Qtraversal(cur->left, vec);
            Qtraversal(cur->right, vec);
        }

        vector<int> preorderTraversal(TreeNode* root)
        {
            vector<int> vec;
            Qtraversal(root, vec);
            return vec;
        }
};

中序遍历

class soulution
{
    public:
        //确定递归函数的参数和返回值
        //中序遍历
        void Ztraversal(TreeNode* cur, vector<int>& vec)
        {
            if(cur == NULL) return;
            Ztraversal(cur->left, vec);
            vec.push_back(cur->val);
            Ztraversal(cur->right);
        }

        vector<int> preorderTraversal(TreeNode* root)
        {
            vector<int> vec;
            Qtraversal(root, vec);
            return vec;
        }
};

后续遍历

class soulution
{
    public:
        //后序遍历
        void Htraversal(TreeNode* cur, vector<int>&vec)
        {
            if(cur == nullptr) return;
            Htraversal(cur->left,vec);
            Htraversal(cur->right,vec);
            vec.push_back(cur->val);
        }

        vector<int> preorderTraversal(TreeNode* root)
        {
            vector<int> vec;
            Qtraversal(root, vec);
            return vec;
        }
};

2、迭代解法

前序遍历

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

中序遍历

class Solution
{
    public:
        vector<int> inorderTraversal(TreeNode* root)
        {
            vector<int> result;
            stack<TreeNode*> st;
            if(root != nullptr)
            {
                TreeNode* cur = root;
                while(cur != nullptr || !st.empty())
                {
                    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;
        }
};

后续遍历

class Solution
{
    public:
        vector<int> postorderTraversal(TreeNode* root)
        {
            stack<TreeNode*> st;
            vector<int> result;
            if(root != nullptr) // 注意空引用
            {
                st.push(root);
                while(!st.empty())
                {
                    TreeNode* node = st.top();
                    result.push_back(node->val);
                    st.pop();

                    if(node->left) st.push(node->left);
                    if(node->right) st.push(node->right);
                }
                reverse(result.begin(), result.end());
                return result;
            }
            return result;
        }
};