代码随想录算法训练营第14天 |理论基础| 递归遍历

本文链接：https://blog.csdn.net/2401_83080774/article/details/136493836

本文详细介绍了二叉树的遍历方式，包括递归遍历（先序、中序、后序）的实现以及迭代遍历的介绍，适合初学者理解二叉树的基本操作。

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

代码随想录算法训练营第14天|理论基础| 递归遍历 | 迭代遍历| 统一迭代

详细布置

理论基础

需要了解二叉树的种类，存储方式，遍历方式以及二叉树的定义

文章讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

递归遍历（必须掌握）

二叉树的三种递归遍历掌握其规律后，其实很简单

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86.html

迭代遍历（基础不好的录友，迭代法可以放过）

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%BF%AD%E4%BB%A3%E9%81%8D%E5%8E%86.html

先序遍历

/**
 * 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:
   /* void traversal(TreeNode *cur,vector<int> &vec)
    {
        if(cur==NULL)
        return ;

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

    }


    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>result;
        traversal(root,result);
        return result;
        
    }*/


    vector<int> preorderTraversal(TreeNode* root)
    {
        stack<TreeNode* > st;
        vector<int>result;
        if(root==NULL)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:
 /*   void traveral(TreeNode *cur,vector<int>&vec)
    {
        if(cur==NULL)
        return ;
        traveral(cur->left,vec);
        vec.push_back(cur->val);
        traveral(cur->right,vec);

    }


    vector<int> inorderTraversal(TreeNode* root)
    {
        vector<int>result;
        traveral(root,result);
        return result;

    }

    */
        vector<int> inorderTraversal(TreeNode* root)
        {
            vector<int>result;
            stack<TreeNode*>st;
            TreeNode*node=root;
            while(node!=NULL||!st.empty())
            {
                if(node!=NULL)
                {
                     st.push(node);
                     node=node->left;

                }
                else
                {
                    node=st.top();
                    st.pop();
                    result.push_back(node->val);
                    node=node->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:
 /*void traveral(TreeNode *cur,vector<int> &vac)//确定递归的值（递归法）
    {
        if(cur==NULL)//确定递归的中断条件
        return ;
        traveral(cur->left,vac);//递归的执行逻辑
        traveral(cur->right,vac);
        vac.push_back(cur->val);
        

    }
/
    vector<int> postorderTraversal(TreeNode* root)
    {
            vector<int>result;//所以参数里需要传入vector来放节点的数值
            traveral(root,result);//进行递归
            return result;//返回遍历
    }*/
        vector<int> postorderTraversal(TreeNode* root)
        {
            stack<TreeNode*>st;
            vector<int>vec;
            if(root==NULL) return vec;
            st.push(root);
            while(!st.empty())
            {
                TreeNode *node=st.top();
                st.pop();
                vec.push_back(node->val);
                if(node->left) st.push(node->left);
                if(node->right) st.push(node->right);

            }
            reverse(vec.begin(),vec.end());
            return vec;
        }
};