二叉树的遍历

已于 2022-10-29 22:44:36 修改
阅读量548 收藏
点赞数
分类专栏： 代码随想录 文章标签： 算法 数据结构 c++
于 2022-10-03 20:25:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38422570/article/details/127146462
版权

目录

二叉树的遍历方式

深度遍历DFS

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

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

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

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

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

广度遍历BFS

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

题目链接：107. 二叉树的层序遍历 II - 力扣（LeetCode）

题目链接：199. 二叉树的右视图 - 力扣（LeetCode）

 题目链接：637. 二叉树的层平均值 题解 - 力扣（LeetCode）

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode）

题目链接：515. 在每个树行中找最大值 - 力扣（LeetCode）

题目链接：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

题目链接：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

二叉树的遍历方式

1.深度优先遍历

  • 前序遍历：根左右
  • 中序遍历：左根右
  • 后序遍历：左右根

2.广度优先遍历

  • 层次遍历

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

class Solution{//前序遍历递归
public:
    vector<int> preorderTraversal(TreeNode *root){
        vector<int> res;
        travel(root,res);
        return res;
    }
private:
    void travel(TreeNode *cur, vector<int> &res){
        if(cur==NULL)   return;
        res.push_back(cur->val);//根
        travel(cur->left,res);//左
        travel(cur->right,res);//右
    }
};

class Solution {//前序遍历迭代
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if(root==NULL)  return res;
        TreeNode *cur=root;
        st.push(root);//将根结点压入栈中                            
        while(!st.empty()){//当栈不为空时，表明其中还有结点未遍历
            //首先将每棵子树的根节点pop并压入res数组
            TreeNode *node=st.top();
            st.pop();
            res.push_back(node->val);                //根
            //先右后左，这样pop出来就是先左后右
            //如果右子树不为空，将右子树根节点压入栈中
            if(node->right) st.push(node->right);    //右
            //如果左子树不为空，将左子树根节点压入栈中
            if(node->left)  st.push(node->left);    //左
        }
        return res;
    }
};

class Solution {//前序遍历统一迭代
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL)  return res;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            //将栈顶结点取出
            TreeNode *cur=st.top();st.pop();
            if(cur!=NULL){//如果栈顶结点不为空
                //重新按照倒序向栈中压入该结点及其孩子
                if(cur->right)  st.push(cur->right);//右
                if(cur->left)   st.push(cur->left); //左
                st.push(cur);                       //根
                
                st.push(NULL);//NULL用来标记根结点所在位置
            }
            else{//如果栈顶结点为空，则要处理根节点，即其上一个结点
                cur=st.top();st.pop();
                res.push_back(cur->val);
            }
        }
        return res;
    }
};

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

class Solution {//中序遍历递归
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL)  return res;
        traversal(root,res);
        return res;
    }
private:
    void traversal(TreeNode *cur,vector<int> &res){
        if(cur==NULL)   return ;
        traversal(cur->left,res);   //左
        res.push_back(cur->val);    //根
        traversal(cur->right,res);  //右
    }
};

class Solution {//中序遍历迭代
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL)  return res;
        stack<TreeNode*> st;
        TreeNode *cur=root;
        while(cur!=NULL||!st.empty()){
            //先将所有左结点压入栈中（在将左结点压入栈中时，其根节点也会压入栈中）
            if(cur!=NULL){
                st.push(cur);   //左
                cur=cur->left;  
            }
            //当结点为叶子结点时，输出该结点，并回到其根节点，将该根节点的右孩子压入栈中
            else{
                cur=st.top();
                st.pop();
                res.push_back(cur->val);    //根
                cur=cur->right;//右
            }
        }
        return res;
    }
};

class Solution {//统一迭代
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if(root!=NULL)  st.push(root);
        TreeNode *cur=root;
        while(!st.empty()){
            TreeNode *cur=st.top();
            if(cur!=NULL){
                st.pop();//虽然之前将根节点push进栈，但处理结点顺序时将根节点pop出来，再按照前序/中序/后序将结点push进栈

                if(cur->right)  st.push(cur->right);//右
                st.push(cur);//根
                st.push(NULL);//根节点访问过但还没处理，加入空结点作为标记
                if(cur->left)   st.push(cur->left);//左
            }else{
                st.pop();//先把NULLpop出来

                cur=st.top();
                st.pop();
                res.push_back(cur->val);//按照push顺序处理结点
            }
        }
        return res;
    }
};

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

class Solution {//后序遍历递归
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL)  return res;
        traversal(root,res);
        return res;
    }
private:
    void traversal(TreeNode *cur,vector<int> &res){
        if(cur==NULL)   return ;
        traversal(cur->left,res);
        traversal(cur->right,res);
        res.push_back(cur->val);
    }
};

class Solution {//后序遍历迭代
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL)  return res;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode *node=st.top();
            st.pop();
            res.push_back(node->val);               //根
            if(node->left)  st.push(node->left);    //左
            if(node->right) st.push(node->right);   //右
        }
        //按照以上得到的是根右左的序列，反转一下就是左右根
        reverse(res.begin(),res.end());
        return res;
    }
};

class Solution {//后序遍历统一迭代
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if(root!=NULL)  st.push(root);
        while(!st.empty()){
            TreeNode *cur=st.top();
            if(cur!=NULL){
                st.pop();
                
                st.push(cur);//根
                st.push(NULL);//虽然根已经刚问过但还没有处理，push空结点作为标记
                if(cur->right)   st.push(cur->right);//右
                if(cur->left)  st.push(cur->left);//左
            }
            else{
                st.pop();//pop出NULL
                cur=st.top();
                st.pop();
                res.push_back(cur->val);
            }
        }
        return res;
    }
};

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

class Solution {//递归
public:
    vector<int> preorder(Node* root) {
        vector<int> res;
        if(root==NULL)  return res;
        travel(root,res);
        return res;
    }
private:
    void travel(Node* root,vector<int> &res){
        res.push_back(root->val);
        //由上面Node的定义可知，children是一个vector<Node*>数组
        for(int i=0;i<root->children.size();i++)
        {
            travel(root->children[i],res);
        }
    }
};

class Solution {//迭代
public:
    vector<int> preorder(Node* root) {
        vector<int> res;
        if(root==NULL)  return res;
        stack<Node*> st;
        st.push(root);
        while(!st.empty()){
            Node *node=st.top();
            st.pop();
            res.push_back(node->val);
            for(int i=node->children.size()-1;i>=0;i--)
            {
                st.push(node->children[i]);
            }
        }
        return res;
    }
};

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

class Solution {//递归
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        if(root==NULL)  return res;
        order(root,res);
        return res;
    }
private:
    void order(Node *cur,vector<int> &res){
        if(cur==NULL)  return ;
        for(int i=0;i<cur->children.size();i++){
            order(cur->children[i],res);
        }
        res.push_back(cur->val);
    }
};

class Solution {//迭代
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        if(root==NULL)  return res;
        stack<Node*> st;
        st.push(root);
        while(!st.empty()){
            Node *cur=st.top();
            st.pop();
            //在N叉树的前序遍历中，children是倒序push的
            for(int i=0;i<cur->children.size();i++){
                st.push(cur->children[i]);
            }
            res.push_back(cur->val);
        }
        //N叉树的后序遍历要反转
        reverse(res.begin(),res.end());
        return res;
    }
};

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

class Solution {//迭代
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //辅助队列
        queue<TreeNode*> q;
        //每一层形成一个数组
        vector<vector<int>> res;
        if(root!=NULL)  q.push(root);
        while(!q.empty())
        {
            //记录每一层的结点数
            int size=q.size();
            vector<int> r;
            for(int i=0;i<size;i++)
            {
                TreeNode *cur=q.front();
                //如果该结点有左右孩子就压入队列
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
                r.push_back(cur->val);
                q.pop();
            }
            res.push_back(r);
        }
        return res;
    }
};

class Solution {//递归
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        int depth=0;
        order(root,res,depth);
        return res;
    }
private:
    void order(TreeNode *cur,vector<vector<int>> &res,int depth){
        if(cur==NULL)   return;
        //如果res目前的数组数==depth，则需要新建一层数组
        if(res.size()==depth)   res.push_back(vector<int>());
        res[depth].push_back(cur->val);
        order(cur->left,res,depth+1);
        order(cur->right,res,depth+1);
    }
};

题目链接：107. 二叉树的层序遍历 II - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> q;
        vector<vector<int>> res;
        if(root!=NULL)  q.push(root);
        while(!q.empty()){
            int size=q.size();
            vector<int> r;
            for(int i=0;i<size;i++){
                TreeNode *cur=q.front();
                r.push_back(cur->val);
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
                q.pop();
            }
            res.push_back(r);
        }
        //反转层次遍历数组
        reverse(res.begin(),res.end());
        return res;
    }
};

题目链接：199. 二叉树的右视图 - 力扣（LeetCode）

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> q;
        vector<int> res;
        if(root!=NULL)  q.push(root);
        while(!q.empty())
        {
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode *cur=q.front();
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
                q.pop();
                //取每层最后一个结点
                if(i==size-1)   res.push_back(cur->val);
            }
        }
        return res;
    }
};

 题目链接：637. 二叉树的层平均值 题解 - 力扣（LeetCode）

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        //层次遍历并计算每层平均值
        vector<double> res;
        queue<TreeNode*> q;
        if(root!=NULL)  q.push(root);
        while(!q.empty()){
            int size=q.size();
            double sum=0;
            for(int i=0;i<size;i++){
                TreeNode *cur=q.front();
                q.pop();
                sum+=cur->val;
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
            }
            res.push_back(sum/size);
        }
        return res;
    }
};

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode）

class Solution {//迭代
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        queue<Node*> q;
        if(root!=NULL)  q.push(root);
        while(!q.empty()){
            int size=q.size();
            vector<int> r;
            for(int i=0;i<size;i++)
            {
                Node *cur=q.front();
                q.pop();
                r.push_back(cur->val);
                for(int j=0;j<cur->children.size();j++){
                    q.push(cur->children[j]);
                }
            }
            res.push_back(r);
        }
        return res;
    }
};

题目链接：515. 在每个树行中找最大值 - 力扣（LeetCode）

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> q;
        if(root!=NULL)  q.push(root);
        while(!q.empty()){
            int size=q.size();
            int max=INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode *cur=q.front();
                q.pop();
                if(cur->val>max)    max=cur->val;
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
            }
            res.push_back(max);
        }
        return res;
    }
};

题目链接：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> q;
        if(root!=NULL)  q.push(root);
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                Node *cur=q.front();
                q.pop();
                //当cur指向每层最后一个结点时，令其next指向NULL，否则指向该层下一个结点
                if(i==size-1)   cur->next=NULL;
                else    cur->next=q.front();
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
            }
        }
        return root;
    }
};

题目链接：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

//当父结点不为空时
//如果父结点cur有左孩子
    //如果temp为空，则说明当前结点cur->left是该层第一个结点，记录下来，下一层的父结点从temp开始；如果temp不为空，则当前结点不是该层第一个结点
    //如果last不为空，则令last->next=当前结点；如果last为空，说明当前结点是该层第一个结点。不管last空不空都要给last赋值当前结点
    //当前结点的next=当前父结点的right
//如果父结点cur有右孩子
    //如果temp为空，同左孩子的temp情况
    //如果last为空，同左孩子的last情况
    //如果父结点的next不为空，则cur=cur->next，继续该层下一个父结点的孩子遍历；如果父结点的next为空，则cur=temp，进行下一层遍历
class Solution {
public:
    Node* connect(Node* root) {
        //cur表示当前遍历到的结点的父结点
        //temp表示同一层第一个访问的结点
        //last表示同一层上一个不为空的结点
        Node *cur=root,*temp=NULL,*last=NULL;
        while(cur){
            if(cur->left){
                if(!temp)   temp=cur->left;
                if(last)    last->next=cur->left;
                cur->left->next=cur->right,last=cur->left;
            }
            if(cur->right){
                if(!temp)   temp=cur->right;
                if(last)    last->next=cur->right;
                if(cur->next)   cur->right->next=cur->next->left,last=cur->right;
            }
            if(cur->next)   cur=cur->next;
            else    cur=temp,temp=NULL,last=NULL;
        }
        return root;
    }
};

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

class Solution {//深度优先遍历
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL)  return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

class Solution {//广度优先遍历
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL)  return 0;
        queue<TreeNode*> q;
        int depth=0;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            depth++;
            for(int i=0;i<size;i++){
                TreeNode *cur=q.front();
                q.pop();
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
            }
        }
        return depth;
    }
};

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

class Solution {
public:
    int minDepth(TreeNode* root) {
        int depth=0;
        queue<TreeNode*> q;
        if(root==NULL)  return 0;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            depth++;
            for(int i=0;i<size;i++){
                TreeNode *cur=q.front();
                q.pop();
                if(cur->left)   q.push(cur->left);
                if(cur->right)  q.push(cur->right);
                //不必比较depth的大小，因为这是层次遍历，只要该结点为叶子节点就一定是最小的深度
                if(cur->left==NULL&&cur->right==NULL)   return depth;
            }
        }
        return depth;
    }
};

二叉树的遍历(深度优先/广度优先 递归/非递归 层序遍历)详解
bitkevin的博客
09-12 1638
目录 1.简介 2.二叉树的深度优先遍历 2.1 二叉树的前序遍历 2.2 二叉树的中序遍历 2.3 二叉树的后序遍历 3. 二叉树的广度优先搜索 3.1 二叉树广度优先搜索 3.2 二叉树的层序遍历 3.3 二叉树自底向上层序遍历 3.4 二叉树的锯齿形层序遍历 二叉树是一种很常用的基本数据结构，它可以看做一种特殊的图(一个节点只有一个入度和最多两个出度)，因此二叉树的的遍历要比图简单很多，学好二叉树也能较容易掌握图的遍历。 1.简介 我们...
c++重拾STL之 队列：queue、deque
元气满满晨
06-03 1939
queue 头文件#include<queue> queue模板类两个模板参数：一个是元素类型，一个是容器类型，容器类型默认为deque类型。 1、定义queue对象： queue<int> q1; queue<BTNode*> q2 2、queue的基本操作 入队： q.push(x); 入到队尾 出队：q.pop(); 弹出队列第一个元素，**注意，pop...
二叉树层序遍历统一化模板
hjxxxxx123491857的博客
08-18 313
BFS广度优先遍历，DFS深度优先遍历统一化模板。 二叉树前中后序遍历
(必背)二叉树的前中后序遍历(利用栈)
alex1997222的博客
01-22 1451
二叉树的前序遍历(利用栈) 1.首先将根节点压入栈 2.栈中的首元素出栈,然后先将其右节点压入栈中,再将栈中的左节点压入栈中(如果左右节点分别存在的话) 3.重复步骤2直到栈为空 class Solution { public: stack<TreeNode*> st; vector<int> preorderTraversal(TreeNode* root) { vector<int> res; if(root
《数据结构与算法分析》学习笔记三——树
qy724728631的博客
08-19 403
 二叉树         一棵二叉树（binary tree）由结点（node）的有限集合组成，这个集合或者为空（empty），或者由一个根结点（root）以及两棵不相交的二叉树组成，这两棵二叉树分别称为这个根的左子树（left subtree）和右子树（right subtree）。这两棵子树的根称为此二叉树根结点的子结点（children）；从一个结点到其两个子结点都有边（edge）相连，这...
看框架中零碎的东西
xuguoer的专栏
07-14 536
extern: 定义在变量或函数之前，表示bian
易语言二叉树遍历
07-21
二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： - 二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 -...
【C语言二叉树遍历实例】C语言二叉树遍历实例
最新发布
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
二叉树遍历流程图（先序、中序、后序、宽度遍历）
05-01
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，主要分为四种类型：先序遍历、中序遍历、后序遍历和宽度优先遍历。这些遍历方法各有特点，适用于不同的场景。 1. **先序遍历**： - **递归实现**：先...
二叉树遍历问题-二叉树遍历问题
11-12
二叉树遍历是计算机科学中的一个重要概念，主要应用于数据结构和算法领域。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树遍历是指按照特定顺序访问二叉树的所有...
二叉树遍历问题 关于二叉树遍历问题的一些总结
07-05
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，对于理解和解决与树相关的算法问题至关重要。本文将深入探讨二叉树的三种遍历方法：先序遍历、中序遍历和后序遍历，并提供相关算法模板。 1. **先序遍历*...
C++基础使用
nbdnbb的博客
08-29 199
C++容器 数组 初始化 int* dp = new int[n+1]; C++比较大小 直接使用max即可 dp[i] = max(1,2);
队列之二叉树的层序遍历
Coding_Physical的专栏
03-08 355
vector<vector<int>> levelOrder(TreeNode *root){ vector<vector<int>> ans; queue<TreeNode *> Q; if (root) { Q.push(root); } while (!Q.empty()) { //获取队列长度 层数 size_t.
层次遍历二叉树(队列解决)
weixin_47511190的博客
11-08 272
#include<bits/stdc++.h> using namespace std; struct Treenode { int data; Treenode *lchild; Treenode *rchild; }; void PrintTree(Treenode *tmp) // 按层次遍历二叉树的函数 { queue<Treenode*>q; q.push(tmp); while(!q.empty()) { Tre
QAQ……queue<node> Q，这操作困扰了我很久
Karen_Yu_的博客
11-11 5200
首先，分享一下我悲剧的经历。听说DFS容易出各种各样莫（ren)名(pin)其(bu)妙(hao)的错，然后BFS各种好，然后就去看了BFS（这就是我悲剧的开端）。先是在网上看别人的代码，然后看到一个： queue Q 这样的写法，很迷，还特地把代码打下来，研究了两个星期。 然后…… 一无所获，之后就去咨询了学长，然后学长告诉我，这个大概是之前定义了结构体。这个时候才发现我看的代码是核心代
链表Node，二叉树TreeNode， 广度优先搜索中压入队列的Node， 字典树中的Node
qq_31617121的博客
03-25 2084
链表Node这么写 class Node { int val; Node next; public Node(int val) { this.val = val; } } Node节点中有个成员变量val，是整型的，代表这个节点的值。next指针指向的是下一个节点。 二叉树TreeNode class TreeNode { int...
102. 二叉树的层序遍历
weixin_43098069的博客
03-13 9092
题目描述： 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]] 示例 2： 输入：root = [1] 输出：[[1]] 示例 3： 输入：root = [] 输出：[] 提示： 树中节点数目在范围 [0, 2000] 内 -1000 <= Node.val <= 1000 来源：力扣（Lee.
C++队列queue基本用法
jiuguaqiao6494的博客
07-13 2496
C++队列queue基本用法定义常用函数 定义 queue <TreeNode*> q; 常用函数 q.push(u) 入队列 q.empty() 判断队列是否为空 q.front() 取队列第一个数的值 q.pop() 删除队列第一个数
leetcode 102. 二叉树的层次遍历【queue实现BFS】
二十四桥明月夜的博客
06-10 416
执行用时 :4 ms, 在所有C++提交中击败了99.43%的用户 内存消耗 :13.9 MB, 在所有C++提交中击败了45.55%的用户 关键： vector<vector<int>> ans; vector<int> tmp; int left=1,next=0; ans：答案 tmp...
二叉树遍历算法详解
“二叉树遍历大全，C语言实现，包含前序、中序、后序遍历的递归和非递归方法。” 在计算机科学中，二叉树是一种特殊的图数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树遍历是访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值