大大普通 2023年11月16日上午10:25

c++
class Solution {
public:
//先记录再删除
//k控制变量
    vector<vector<int>> decorateRecord(TreeNode* root) {
     bool k=true;//-->
     vector<vector<int>>ans;
     vector<TreeNode*>q;//模拟队列 只不过队列实现单边 数组实现双端
     if(root==NULL)return ans;
     q.push_back(root);
     while(q.size()!=0){         
         int l=0,r=q.size()-1;
         vector<int>a;

         //记录每层的值
         for(int i=q.size();i>0;i--){//表示每层的个数
          if(k){
              a.push_back(q[l++]->val);
          }else{
             a.push_back(q[r--]->val);
          }          
         }

         //加入下一层的值
         int n=q.size();
         for(int i=0;i<n;i++){
             if(q[i]->left)q.push_back(q[i]->left);
             if(q[i]->right)q.push_back(q[i]->right);
         }
         //删除本层的值
         q.erase(q.begin()+0,q.begin()+n);
         ans.push_back(a);
         //调换顺序
         k=k?false:true;
     }
     return ans;
    }
};

0 赞同 1 条回复

大大普通 @ 大大 2023年12月20日下午4:54

 //1 跟上个一样，只不过swap下
 //2 存入的时候就直接倒过来
 //2
class Solution {
public:
    vector<vector<int>> decorateRecord(TreeNode* root) {
      vector<vector<int>>ans;
      queue<TreeNode*>q;
      if(root==NULL)return ans;
      int k=1,h,s;
      q.push(root);
      while(!q.empty()){ 
          if(k&1)  h=1,s=0;
          else h=-1,s=q.size()-1;     
      vector<int>res(q.size());
      for(int i=q.size();i>0;i--){
        TreeNode* top=q.front();
        q.pop();
        res[s]=top->val;
        s+=h;

        if(top->left)q.push(top->left);
        if(top->right)q.push(top->right);
      }k++;
      ans.push_back(res);
      }
      return ans;
    }
};

招舟子普通 2023年8月26日下午1:13

“`java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List> levelOrder(TreeNode root) {
if(root==null){
return new ArrayList<>();
}
List> res = new ArrayList<>();
Queue queue = new LinkedList<>();
int num = 0;
queue.offer(root);
while(!queue.isEmpty()){
LinkedList tmp = new LinkedList<>();
int k = queue.size();
for(int i=0;ireturn res;

}
}借助LinkedList的addFirst在前边加入，实现左右便利

0 赞同 0 条回复

jhfuture 普通 2023年8月11日下午10:33

原本想的是使用一个栈进行处理，但是后面看到帅地使用 linkedList进行了优化

“`java
//时间复杂度为O(n) 空间复杂度为 O(n)
class Solution {
public List> levelOrder(TreeNode root) {
if(root==null) return new ArrayList<>();
int sum=1;
Queue queue = new LinkedList();
List> res= new ArrayList<>();
queue.add(root);

    while(!queue.isEmpty()){
        // 里面有K 个则一层有k个
        int k= queue.size();
        // 边去取一层，边放入 。自己原本的思想是分开处理
        LinkedList tmp=new LinkedList<Integer>();

        for(int i=0;i<k;i++){

            TreeNode t=queue.poll();
            // 插入时进行判断
       if(sum%2!=0){
           //奇数正常

tmp.add(t.val);
}else{
//偶数的是2，从右到左
tmp.addFirst(t.val);
}

          if(t.left!=null) queue.add(t.left);
          if(t.right!=null) queue.add(t.right);

        }
        // 循环接触则得到了一层
        res.add(tmp);
        sum++;
    }
    return res;
}

}
///以下为使用栈进行解决
public List<List> levelOrder(TreeNode root) {
if(rootnull) {return new ArrayList<>();}
int sum=1;
Queue queue = new LinkedList();
List<List> res= new ArrayList<>();
queue.add(root);

    while(!queue.isEmpty()){
        // 里面有K 个则一层有k个
        int k= queue.size();
        // 边去取一层，边放入 。自己原本的思想是分开处理
        List tmp=new ArrayList<Integer>();

// 插入式进行判断
if (sum%2!=0){
for(int i=0;i<k;i++){

                TreeNode t=queue.poll();
                tmp.add(t.val);
                if(t.left!=null) {queue.add(t.left);}
                if(t.right!=null) {queue.add(t.right);}

            }
        }else {
            Stack<Integer> integers = new Stack<>();
            for (int i = 0; i < k; i++) {
                TreeNode t=queue.poll();
                integers.push(t.val);
                if(t.left!=null) {queue.add(t.left);}
                if(t.right!=null) {queue.add(t.right);}
            }
            while (!integers.isEmpty()){
                tmp.add(integers.pop());
            }

        }

        // 循环接触则得到了一层
        res.add(tmp);
        sum++;
    }
    return res;
}

0 赞同 0 条回复

淡色花樱普通 2023年8月2日下午9:52

“`java
时间复杂度O(n) 空间复杂度0(n)
class Solution{
public List> levelOrdder(TreeNode root){
if(root == null){
return new ArrayList<>();
}
Queue queue = new LinkList<>();
Listres = new ArrrayList<>();
int sum = 1;
queue.add(root);
while(!queue.isEmpty(){
int k = queue.size();
LinkedList tmp = new LinkedList<>();
for(int i =0; i

0 赞同 0 条回复

断舍离永久会员 2023年7月10日下午4:17

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //决定是从左至右还是从右至左
        //根元素从左至右，那么第二层元素从右至左，以此类推，默认设为true
        boolean flag = true;
        if(root == null){
            return new ArrayList<>();
        }
        LinkedList<TreeNode> queue = new LinkedList();
        List<List<Integer>> result = new ArrayList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            //获得当前队列共有多少元素
            int k = queue.size();
            //存放该层元素的集合
            LinkedList<Integer> temp = new LinkedList<>();
            for(int i = 0; i < k; i++){
                TreeNode node = queue.poll();
                //从左至右
                if(flag){
                    temp.add(node.val);
                //从右至左
                }else {
                    temp.addFirst(node.val);
                }
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
            //更换下次加入顺序
            flag = !flag;
            //加入本层元素集合
            result.add(temp);
        }
        return result;
    }
}

0 赞同 0 条回复

CV大神普通 2023年7月10日上午9:29

public List<List<Integer>> levelOrder1(TreeNode root) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> values = new ArrayList<>();
        if (root != null) {
            queue.addLast(root);
        }
        boolean isOrder = true;
        //画个图更好理解
        while (!queue.isEmpty()) {
            //当前层级的个数
            int currentLevelSize = queue.size();
            LinkedList<Integer> levelList = new LinkedList<>();
            for (int i = 0; i < currentLevelSize; i++) {
                TreeNode node = queue.pollFirst();
                if (isOrder) {
                    levelList.add(node.val);
                } else {
                    levelList.addFirst(node.val);
                }
                if (node.left != null) {
                    queue.addLast(node.left);
                }
                if (node.right != null) {
                    queue.addLast(node.right);
                }
            }
            values.add(levelList);
            isOrder = !isOrder;

        }
        return values;
    }

时间复杂度O(n，空间复杂度O(n)

0 赞同 0 条回复

mpweixin用户普通 2023年7月8日下午5:47

C++实现

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> q;

        if(!root) return res;
        q.push(root);
        int count = -1;

        while(!q.empty()){
            vector<int> temp;
            for(int i = q.size(); i > 0; i--){
                TreeNode* node = q.front();
                q.pop();
                temp.push_back(node->val);
                if(node->left!=NULL) q.push(node->left);
                if(node->right!=NULL) q.push(node->right);
            }
            count++;
            if(count%2 != 0){
                reverse(temp.begin(), temp.end());
            }
            res.push_back(temp);
        }
        return res;
    }
};

0 赞同 0 条回复

憨憨永久会员 2023年7月7日下午5:45

通过一个数字id来判断是否倒序打印，然后每层储存数值就可以了

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null)return new ArrayList<>();
        List<List<Integer>> ans=new ArrayList<>();
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        int id=0;
        while(!queue.isEmpty()){
            int a=queue.size();
            int[] arr=new int[a];
            TreeNode node=null;
            for(int i=0;i<a;i++){
                node=queue.poll();
                arr[i]=node.val;
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
            List<Integer> temp=new ArrayList<>();
            if((id++)%2==0){
                for(int c:arr){
                    temp.add(c);
                }
            }else{
                for(int i=arr.length-1;i>=0;i--){
                    temp.add(arr[i]);
                }
            }
            ans.add(temp);
        }
        return ans;
    }
}

0 赞同 0 条回复

BOZ 普通 2023年7月7日下午1:07

【思路】通过result数组的长度来判断当前是第几行，是否需要reverse print，normal print和reverse print分别通过vector的push_back、insert(xx.begin(), val)函数来实现
【复杂度】时间/空间均为O(n)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if (!root) return result;

        std::queue<TreeNode*> q;
        q.push(root);

        while(!q.empty()) {
            int level_size = q.size();
            std::vector<int> level_result;
            bool left = result.size() & 1;

            for(int k = 0;k < level_size; k++) {
                auto node = q.front();
                q.pop();
                if (left) level_result.insert(level_result.begin(), node->val);
                else level_result.push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            result.push_back(level_result);
        }
        return result;
    }
};

0 赞同 0 条回复

Sexypig. 普通 2023年7月6日下午1:11

法一：利用反转标记，调用reverse函数对反转行反转后再插入ans；
法二：利用双端队列，依然设立反转行标记，需要反转的行依次插入双端队列的头部实现反转。

#include<iostream>
#include<vector>
#include<queue>
#include<deque>
using namespace std;

// 定义二叉树的节点结构
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//法一：利用反转标记，调用reverse函数对反转行反转后再插入ans

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if (!root) return {}; // 如果根节点为空，则返回空结果

        vector<vector<int>> ans; // 用于存储结果的二维数组
        queue<TreeNode*> q; // 用于进行层次遍历的队列
        q.push(root); // 将根节点入队
        bool flag = false; //标记反转行
        while (!q.empty()) { // 当队列不为空时，进行层次遍历
            int size = q.size(); // 获取当前层的节点个数
            vector<int> arr; // 用于存储当前层的节点值

            while (size > 0) {
                TreeNode* cur = q.front(); // 获取队首节点
                q.pop(); // 弹出队首节点
                arr.push_back(cur->val); // 将节点值存入当前层的结果数组
                if (cur->left) q.push(cur->left); // 如果有左子节点，则将左子节点入队
                if (cur->right) q.push(cur->right); // 如果有右子节点，则将右子节点入队
                --size; // 当前层的节点数减一
            }
            if (flag)   reverse(arr.begin(), arr.end()); //若需要反转，则反转
            flag = !flag;
            ans.push_back(arr); // 将当前层的结果数组存入最终结果数组
        }

        return ans; // 返回最终结果数组
    }
};

//法二：利用双端队列，依然设立反转行标记，需要反转的行依次插入双端队列的头部实现反转。

class Solution2 {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if (!root) return {}; // 如果根节点为空，则返回空结果

        vector<vector<int>> ans; // 用于存储结果的二维数组
        queue<TreeNode*> q; // 用于进行层次遍历的队列
        q.push(root); // 将根节点入队
        bool flag = false; //标记反转行


        while (!q.empty()) { // 当队列不为空时，进行层次遍历
            int size = q.size(); // 获取当前层的节点个数
            vector<int> arr; // 用于存储当前层的节点值
            deque<int> d;

            while (size > 0) {
                TreeNode* cur = q.front(); // 获取队首节点
                q.pop(); // 弹出队首节点
                if (flag)
                    d.push_front(cur->val);//需要反转，插入头部
                else    
                    d.push_back(cur->val);
                if (cur->left) q.push(cur->left); // 如果有左子节点，则将左子节点入队
                if (cur->right) q.push(cur->right); // 如果有右子节点，则将右子节点入队
                --size; // 当前层的节点数减一
            }

            ans.push_back(vector<int>{d.begin(),d.end()}); // 将当前层的结果数组存入最终结果数组
        }

        return ans; // 返回最终结果数组
    }
};

0 赞同 0 条回复

名字什么的好麻烦普通 2023年7月4日下午2:21

标记

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> list = new ArrayList<>();
        if(root==null)
            return list;
        queue.offer(root);
        int flag=0;
        while(!queue.isEmpty()){
            flag++;
            List<Integer> res = new ArrayList<>();
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                res.add(node.val);
                if(node.left!=null)
                    queue.offer(node.left);
                if(node.right!=null)
                    queue.offer(node.right);
            }
            if(flag%2!=0)
                list.add(res);
            else{
                Collections.reverse(res);
                list.add(res);
            }
        }
        return list;
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年7月4日下午12:21

java
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null) {
            //return null;
            return new ArrayList<>();
        }
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        TreeNode tmp = root;
        q.add(root);
        int judge_odd = 1;
        while(!q.isEmpty()) {
            int k = q.size();
            LinkedList<Integer> list = new LinkedList<>();
            for(int i = 0; i < k; i++) {
                //把每一层的元素压入后取出就是一层
                tmp = q.poll();
                if(judge_odd % 2 == 1) {//奇数行正常列出，偶数行反着列出
                    list.add(tmp.val);
                } else {
                    list.addFirst(tmp.val); //LinkedList的addFirst方法
                }
                if(tmp.left != null) {
                    q.add(tmp.left);
                }
                if(tmp.right != null) {
                    q.add(tmp.right);
                }
            }
            judge_odd ++;
            res.add(list);
        }
        return res;
    }
}

时间复杂度和空间复杂度都是O(N)

0 赞同 0 条回复

局外人普通 2023年7月3日下午9:36

思路：按照上一个II版本，加入一个z字走形控制变量，来控制Collection.reverse()来翻转每层元素的列表
时间复杂度O(n) 空间复杂度O(n)

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root==null)  return res;

        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(root);
        TreeNode rear = root;

        boolean turn = false;

        while(!queue.isEmpty()){
            int sz = queue.size();
            List<Integer> list = new LinkedList<>();

            for(int i=0; i<sz; i++){
               TreeNode cur = queue.poll();
                list.add(cur.val);

                if(cur.left!=null)  queue.offer(cur.left);
                if(cur.right!=null) queue.offer(cur.right);

            }

            if(turn)    Collections.reverse(list);
            turn = !turn;
            res.add(list);

        }
        return res;
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年7月3日下午6:40

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    /* 特判 */
    if (!root) {
        *returnSize = 0;
        *returnColumnSizes = NULL;
        return NULL;
    }
    /* 返回数组的行数 */
    *returnSize = 0;
    /* 返回数组 */
    int** res = (int**)malloc(sizeof(int*) * 10001);
    /* 返回数组中每一行的列数 */
    *returnColumnSizes = (int*)malloc(sizeof(int) * 10001);
    /* 队列 */
    struct TreeNode** queue = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * 10001);
    int head = 0, rear = 0;
    queue[rear++] = root;
    /* 遍历二叉树 */
    while (head < rear) {
        /* 记录当前的rear */
        int preRear = rear;
        /* 当前行的列数 */
        res[*returnSize] = (int*)malloc(sizeof(int) * (preRear - head));
        (*returnColumnSizes)[*returnSize] = preRear - head;
        int index;
        if (*returnSize % 2 == 0) {
            index = 0;
        } else {
            index = preRear - head - 1;
        }
        /* 遍历当前行 */
        for (; head < preRear; head++) {
            if (*returnSize % 2 == 0) {
                res[*returnSize][index++] = queue[head]->val;
            } else {
                res[*returnSize][index--] = queue[head]->val;
            }
            /* 添加当前节点的左右孩子 */
            if (queue[head]->left) {
                queue[rear++] = queue[head]->left;
            }
            if (queue[head]->right) {
                queue[rear++] = queue[head]->right;
            }
        }
        /* 遍历层数加一 */
        (*returnSize)++;
    }
    return res;
}

时间复杂度为O(N)
空间复杂度为O(N)

0 赞同 0 条回复

花老爷普通 2023年6月30日上午11:43

bfs，用size确定每一层节点数，leftToRight表示是否从左向右，若是false，即从右向左，直接将subRes反转即可。
时间：O(n)
空间：O(n)

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);
        boolean leftToRight = true;
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> subRes = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode temp = queue.poll();
                if (temp.left != null) {
                    queue.offer(temp.left);
                }
                if (temp.right != null) {
                    queue.offer(temp.right);
                }
                subRes.add(temp.val);
            }
            if (!leftToRight) {
                Collections.reverse(subRes);
            }
            res.add(subRes);
            leftToRight = !leftToRight;
        }
        return res;
    }
}

0 赞同 0 条回复

～普通 2023年6月29日下午6:16

class Solution {
public:
vector<vector> levelOrder(TreeNode* root) {
vector<vector> res;
queue<TreeNode> q;
if(rootnullptr){
return res;
}
q.push(root);
bool level = true;
while(!q.empty()){
int sz = q.size();
vector ans(sz);
for(int i=0;i<sz;i++){
TreeNode node = q.front();
q.pop();
int index = level? i:sz-i-1;
ans[index] = node->val;
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
level = !level;
res.push_back(ans);
}
return res;
}
};
时间复杂度O(n) 空间复杂度O(n)

0 赞同 0 条回复

peach 普通 2023年6月29日下午12:16

思路

Z字形打印
时间复杂度O(n) 空间复杂度O(n)

代码

 //Z字形层序遍历
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList();
        if(root == null) return res;
        Deque<TreeNode> queue = new ArrayDeque();
        queue.addLast(root);
        int size;
        int count = 0;
        while(!queue.isEmpty()){
            size = queue.size();
            List<Integer> list = new ArrayList();
            while(size-- > 0){
                root = queue.removeFirst();
                list.add(root.val);
                if(root.left != null) queue.addLast(root.left);
                if(root.right != null) queue.addLast(root.right);
            }
            count++; //区别是这里，隔一层打印顺序不同，就是隔一层要反转一下集合
            if(count % 2 == 0) Collections.reverse(list);
            res.add(list);
        }
        return res;
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年6月29日上午8:16

第一种做法，使用双向队列，奇数层偶数层在不同方向插入队列
时间复杂度: O(n)
空间复杂度: O(n)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> >res;
        if (!root) {
            return res;
        }
        deque<TreeNode*>que;
        que.push_back(root);
        bool flag = true;
        while (!que.empty()) {
            int sz = que.size();
            vector<int>level;
            for (int i = 0; i < sz; i++) {
                if (flag) {
                    // get from front, push to back
                    TreeNode* curr = que.front();
                    que.pop_front();
                    level.push_back(curr->val);
                    if (curr->left) {
                        que.push_back(curr->left);
                    }
                    if (curr->right) {
                        que.push_back(curr->right);
                    }
                } else {
                    // get from back, push to front
                    TreeNode* curr = que.back();
                    que.pop_back();
                    level.push_back(curr->val);
                    if (curr->right) {
                        que.push_front(curr->right);
                    }
                    if (curr->left) {
                        que.push_front(curr->left);
                    }
                }
            }
            res.push_back(level);
            flag = !flag;
        }
        return res;
    }
};

方法二: 正常层序遍历，最后在返回前，将偶数层全部翻转
时间复杂度: O(n)
空间复杂度: O(n)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> >res;
        if (!root) {
            return res;
        }
        queue<TreeNode*>que;
        que.push(root);
        while (!que.empty()) {
            int sz = que.size();
            vector<int>level;
            for (int i = 0; i < sz; i++) {
                TreeNode* curr = que.front();
                que.pop();
                level.push_back(curr->val);
                if (curr->left) {
                    que.push(curr->left);
                }
                if (curr->right) {
                    que.push(curr->right);
                }
            }
            res.push_back(level);
        }
        for (int i = 0; i < res.size(); i++) {
            if (i % 2 != 0) {
                reverse(res[i].begin(), res[i].end());
            }
        }
        return res;
    }
};

0 赞同 0 条回复

哈哈哈哈开开心心普通 2023年6月29日上午6:38

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

from collections import deque

class Solution:
    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []

        if not root:
            return res

        q = deque([root])
        level = 0

        while q:
            cur_lst = []
            size = len(q)
            level += 1

            for i in range(size):
                cur = q.popleft()
                cur_lst.append(cur.val)
                if cur.left:
                    q.append(cur.left)
                if cur.right:
                    q.append(cur.right)

            if level % 2 == 0:
                cur_lst.reverse()

            res.append(cur_lst)

        return res
# 记得reverse

0 赞同 0 条回复

江畅普通 2023年6月28日下午11:33

// 之字形层序遍历二叉树
// 时间复杂度 O(N)
// 空间复杂度 O(N)
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if (root == nullptr) {
            return {};
        }

        vector<vector<int>> res;
        queue<TreeNode*>    que;

        que.push(root);
        bool isOrderLeft = true; // 之字形遍历顺序

        while (!que.empty()) {
            int size = que.size(); // 每层节点个数

            deque<int> deq;        // 双端队列存放之字形的每层遍历
            while (size--) {
                TreeNode* node = que.front();

                if (isOrderLeft) {
                    deq.push_back(node->val);
                }
                else {
                    deq.push_front(node->val);
                }

                if (node->left != nullptr) {
                    que.push(node->left);
                }
                if (node->right != nullptr) {
                    que.push(node->right);
                }

                que.pop();
            }
            // push_back 与 emplace_back 性能差异
            res.emplace_back(vector<int>{deq.begin(), deq.end()});
            isOrderLeft = !isOrderLeft;
        }
        return res;
    }
};

0 赞同 0 条回复

张君雅小妹妹普通 2023年6月28日下午10:54

时间复杂度：O(N)
空间复杂度：O(N)

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null) return new ArrayList<>();

        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();

        boolean flag = true; // true:顺序 false：逆序
        queue.add(root);
        while(!queue.isEmpty()){
            int k = queue.size();
            LinkedList<Integer> list = new LinkedList<>();
            for(int i = 0; i < k; i++){
                TreeNode tmpNode = queue.poll();
                if(flag){
                    list.add(tmpNode.val);
                } else {
                    list.addFirst(tmpNode.val);
                }
                if(tmpNode.left != null) queue.offer(tmpNode.left);
                if(tmpNode.right != null) queue.offer(tmpNode.right);
            }
            res.add(list);
            flag = !flag;
        }
        return res;

    }
}

0 赞同 0 条回复

屠龙手段普通 2023年6月28日上午10:11

用临时数组寄存，反向遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        queue = [root]
        res = []
        flag = True
        while queue:
            tmp = []
            tmp_queue = []
            for _ in range(len(queue)):
                if flag:
                    cur_node = queue[0]
                    queue = queue[1:]
                else:
                    cur_node = queue.pop()
                tmp.append(cur_node.val)
                if flag:
                    if cur_node.left:
                        tmp_queue.append(cur_node.left)
                    if cur_node.right:
                        tmp_queue.append(cur_node.right)
                else:
                    if cur_node.right:
                        tmp_queue.append(cur_node.right)
                    if cur_node.left:
                        tmp_queue.append(cur_node.left)
            res.append(tmp)
            queue = tmp_queue if flag == True else tmp_queue[::-1]
            flag = not flag
        return res

0 赞同 0 条回复

小吕普通 2023年6月28日上午8:56

c++实现，使用双端队列的可能会更好一点，但是我不会
vector<vector> levelOrder(TreeNode* root) {
vector<vector> result;
queue<TreeNode>que;
if(rootNULL)return result;
que.push(root);
int deep = 0;
while(!que.empty())
{
int len = que.size();
deep++;
vector temp;
TreeNode tempNode;
for(int i = 0;i<len;i++)
{
tempNode = que.front();
que.pop();
temp.push_back(tempNode->val);
if(tempNode->left!=NULL)que.push(tempNode->left);
if(tempNode->right!=NULL)que.push(tempNode->right);
}
if(deep%20)
{
reverse(temp.begin(),temp.end());
}
result.push_back(temp);
}
return result;
}

0 赞同 0 条回复

张开怀普通 2023年6月27日下午7:13

public:
       vector<vector<int>> levelOrder(TreeNode* root){
              if(!root){
                     return { };   
              }

              queue<TreeNode*> q{{root}};
              vector<vector<int>> res;
              int sum=1;          // 奇偶标记位
              while(!q.empty()){
                     int n = q.size();
                     vector<int> level(n);
                     for (int i=0; i<n; i++){
                            auto t = q.front();
                            q.pop();
                            if(sum%2 == 1){
                                   level[i] = t->val;
                            }else{
                                   level[n-1-i] = t->val;
                            }
                            if(t->left){
                                   q.push(t->left);
                            }
                            if(t->right){
                                   q.push(t->right);
                            }
                     }
                     res.push_back(level);
                     sum++;
              }
              return res;
       }

时间复杂度：O(n)
空间复杂度：O(n)

0 赞同 0 条回复

怀瑾永久会员 2023年6月27日下午5:34

C++实现

#include <iostream>
#include <vector>
#include <deque>

using namespace std;

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

vector<vector<int>> printZigzag(TreeNode* root) {
    vector<vector<int>> res;
    if (root == NULL)
        return res;

    deque<TreeNode*> q;
    q.push_back(root);
    bool flag = true;

    while (!q.empty()) {
        int levelSize = q.size();
        vector<int> level(levelSize);

        for (int i = 0; i < levelSize; i++) {
            TreeNode* node = NULL;
            if (flag) {
                node = q.front();
                q.pop_front();
                if (node->left)
                    q.push_back(node->left);
                if (node->right)
                    q.push_back(node->right);
            } else {
                node = q.back();
                q.pop_back();
                if (node->right)
                    q.push_front(node->right);
                if (node->left)
                    q.push_front(node->left);
            }

            level[i] = node->val;
        }
        res.push_back(level);
        flag = !flag;
    }

    return res;
}

int main() {
    TreeNode* root = new TreeNode(3);
    root->left = new TreeNode(9);
    root->right = new TreeNode(20);
    root->right->left = new TreeNode(15);
    root->right->right = new TreeNode(7);

    vector<vector<int>> res = printZigzag(root);
    for (auto vec : res) {
        for (auto val : vec) {
            cout << val << " ";
        }
        cout << endl;
    }

    return 0;
}

0 赞同 0 条回复

彦，，# 普通 2023年6月27日下午5:13

vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
         vector<vector<int>> res;
         /* 定义一个队列用于存储节点的数据 */
        queue<TreeNode*> q;
        if(root != nullptr) q.push(root);
        bool p_flag = false; //从右到左 从第二列开始
        while(!q.empty())
        {
            vector<int> vv;
            int n = q.size();
            for(int i =0;i<n;i++)
            {
                TreeNode* temp = q.front();
                q.pop();
                vv.push_back(temp->val);
                if(temp->left != nullptr) q.push(temp->left); 
                if(temp->right != nullptr) q.push(temp->right); 
            }
            if(p_flag) reverse(vv.begin(),vv.end());
            p_flag = !p_flag;
            res.push_back(vv);
        }
        return res;
    }

0 赞同 0 条回复

普通 2023年6月27日下午4:37

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> que = new LinkedList<>();
        if(root != null) que.add(root);
        List<List<Integer>> resultList = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        boolean isReverse = false;
        TreeNode front = null;
        while(!que.isEmpty()){
            TreeNode index =  que.poll();
            if(front == null){
                que.add(null);
            }
            front = index;
            if(index == null){
                if(!list.isEmpty()){
                    if(isReverse){
                        Collections.reverse(list);
                    }
                    isReverse = isReverse ? false : true;
                    resultList.add(list);
                }
                list = new ArrayList<>();
                continue;
            }
            list.add(index.val);
            if(index.left != null){
                que.add(index.left);
            }
            if(index.right != null){
                que.add(index.right);
            }
        }
        return resultList;
    }
}

层序遍历，利用队列NULL值隔离每层元素，通过Collections.reverse反转list

0 赞同 0 条回复

大鑫啊普通 2023年6月27日下午3:07

时空复杂度：O(n)
1、对比于上一道题，需要在奇偶层进行判断是否要对临时链表进行从尾部插入从而实现倒叙输出

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null)return new ArrayList();
        Queue<TreeNode> queue = new LinkedList();
        List<List<Integer>> res = new ArrayList();
        queue.offer(root);
        int sum = 1;
        while(!queue.isEmpty()){
            int k = queue.size();
            LinkedList<Integer> tmp = new LinkedList();
            for(int i=0;i<k;i++){
                TreeNode t = queue.poll();
                if(sum % 2 == 1){
                    tmp.add(t.val);
                }else{
                    tmp.addFirst(t.val);
                }
                if(t.left != null)queue.offer(t.left);
                if(t.right != null)queue.offer(t.right);

            }
            res.add(tmp);
            sum++;
        }
        return res;
    }
}

0 赞同 0 条回复

Vow the vow。普通 2023年6月27日上午11:56

用双端队列来实现从左往右和从右往左遍历的效果。

public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> deque = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        deque.add(root);
        int left2right = 1;
        while(!deque.isEmpty()){
            int m = deque.size();
            List<Integer> list = new ArrayList<>();
            while(m-- > 0){
                if(left2right == 1){
                    TreeNode node = deque.pollFirst();
                    list.add(node.val);
                    if(node.left != null) deque.addLast(node.left);
                    if(node.right != null) deque.addLast(node.right);
                }else{
                    TreeNode node = deque.pollLast();
                    list.add(node.val);
                    if(node.right != null) deque.addFirst(node.right);
                    if(node.left != null) deque.addFirst(node.left);

                }
            }
            left2right = -left2right;
            res.add(list);
        }
        return res;
    }

0 赞同 0 条回复

désire. 普通 2023年6月27日上午9:21

C++实现：
class Solution {
public:
vector<vector> levelOrder(TreeNode* root) {
vector<vector> res;
if (rootNULL)
return res;
bool flag = true; //从左向右打印为true，从右向左打印为false
deque<TreeNode> q;
q.push_back(root);
while (!q.empty())
{
int n = q.size();
vector out;
TreeNode node;
while (n>0)
{
if (flag) // 前取后放：从左向右打印，所以从前边取，后边放入
{
node = q.front();
q.pop_front();
if (node->left)
q.push_back(node->left); // 下一层顺序存放至尾
if (node->right)
q.push_back(node->right);
}
else //后取前放：从右向左，从后边取，前边放入
{
node = q.back();
q.pop_back();
if (node->right)
q.push_front(node->right); // 下一层逆序存放至首
if (node->left)
q.push_front(node->left);
}
out.push_back(node->val);
n–;
}
flag = !flag;
res.push_back(out);
}
return res;
}
};

0 赞同 0 条回复

硬核洋葱普通 2023年6月26日下午11:05

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        deque<TreeNode*> treeque;
        vector<vector<int>> ans;
        vector<int> layerans;
        if(!root)   return ans;

        bool mode = 0;
        treeque.push_back(root);
        while(!treeque.empty()){
            int layersize = treeque.size();
            for(int i = 0; i < layersize; ++i){
                if(mode){
                    TreeNode *node = treeque.back();
                    treeque.pop_back();
                    if(node->right)
                        treeque.push_front(node->right);
                    if(node->left)
                        treeque.push_front(node->left);
                    layerans.push_back(node->val);
                }
                else{
                    TreeNode *node = treeque.front();
                    treeque.pop_front();
                    if(node->left)
                        treeque.push_back(node->left);
                    if(node->right)
                        treeque.push_back(node->right);
                    layerans.push_back(node->val);
                }
            }
            mode = !mode;
            ans.push_back(layerans);
            layerans = {};
        }

        return ans;
    }
};

双端队列，若该层从左往右打印，则和之前的题一样
如果要求从右往左，则从队列 back 开始取，先右子节点后左子节点从 front 入队
时间复杂度O(n) 空间复杂度O(n)

0 赞同 0 条回复

橙子陈普通 2023年6月26日下午11:01

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (null == root) return new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        List<List<Integer>> res = new ArrayList<>();
        int height = 1;
        while(!queue.isEmpty()){
            int k = queue.size();

            LinkedList<Integer> ans = new LinkedList<>();
            for (int i = 0; i < k; i++){
                TreeNode t = queue.poll();
                if (height % 2 == 1){
                    ans.add(t.val);
                } else {
                    ans.addFirst(t.val);
                }

                if (null != t.left) queue.add(t.left);
                if (null != t.right) queue.add(t.right);
            }
            res.add(ans);
            height++;
        }

        return res;
    }
}

时间复杂度O(n)
空间复杂度O(n)

0 赞同 0 条回复

Jerry 普通 2023年6月26日下午10:34

//BFS + 队列
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return new ArrayList<>();
        List<List<Integer>> orders = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>() {{ add(root); }};
        while (!queue.isEmpty()) {
            LinkedList<Integer> order = new LinkedList<>();
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                // 根据orders的size 来实现左右来回顺序打印
                if (orders.size() % 2 == 0) {
                    order.addLast(node.val);
                } else {
                    order.addFirst(node.val);
                }
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            orders.add(order);
        }
        return orders;
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

0 赞同 0 条回复

伏月三十普通 2023年6月26日下午10:17

时间复杂度：O(n)；空间复杂度：O(n)

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        LinkedList<TreeNode> queue=new LinkedList<>();

        int c=1;
        queue.add(root);
        while(!queue.isEmpty()){
            int k=queue.size();
            LinkedList<Integer> res=new LinkedList<>(); //注意这里new的是LinkedList 可以实现在头部插入
            for(int i=0;i<k;i++){
                TreeNode poll=queue.poll();
                if(c%2!=0){
                    res.add(poll.val); //在集合尾部插
                }else{
                    res.addFirst(poll.val);//在集合头部插
                }

                if(poll.left!=null){
                    queue.add(poll.left);
                }
                if(poll.right!=null){
                    queue.add(poll.right);
                }
            }
            c++;
            result.add(res);
        }
        return result;
    }
}

0 赞同 0 条回复

行动派小彩笔普通 2023年6月26日下午9:59

// 时间复杂度O(n),空间复杂O(n),通过标志位来判断是从左还是从右开始
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(!root) return ans;
        deque<TreeNode*> d;
        d.push_back(root);
        ans.push_back(vector<int>{root->val});
        bool flag = true;
        while(!d.empty())
        {
            vector<int> v;
            int n =d.size();
            for(;n>0;--n)
            {
                if(flag)
                {
                    TreeNode* tmp = d.back();
                    d.pop_back();
                    if(tmp->right)
                    {
                        d.push_front(tmp->right);
                        v.push_back(tmp->right->val);
                    }
                    if(tmp->left)
                    {
                        d.push_front(tmp->left);
                        v.push_back(tmp->left->val);
                    }
                }
                else
                {
                     TreeNode* tmp = d.front();
                     d.pop_front();
                     if(tmp->left)
                     {
                         d.push_back(tmp->left);
                         v.push_back(tmp->left->val);
                     }
                     if(tmp->right)
                     {
                         d.push_back(tmp->right);
                         v.push_back(tmp->right->val);
                     }
                }
            }
            flag=!flag;
            if(v.size())
                ans.push_back(v);
        }
        return ans;

    }
};
 // 通过奇偶层数来判断
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(!root) return ans;
        queue<TreeNode*> q;
        q.push(root);
        int level = 1;
        while(!q.empty())
        {
            int n = q.size();
            vector<int> v(n);
            for(int i =0;i<n;++i)
            {
                TreeNode* tmp = q.front();;
                q.pop();
                if(level%2==1) v[i]=tmp->val;         
                else v[n-i-1] = tmp->val;
                if(tmp->left) q.push(tmp->left);
                if(tmp->right) q.push(tmp->right);
            }
            ++level;
            ans.push_back(v);
        }
        return ans;
    }
};

0 赞同 0 条回复

yxy 普通 2023年6月26日下午9:06

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root) return res;
        queue<TreeNode*> q;
        stack<TreeNode*> st;
        q.push(root);
        int flag=1;
        while(q.size())
        {
            vector<int> vec;
            int n=q.size();
            while(n--)
            {
                auto cur=q.front();
                q.pop();
                vec.push_back(cur->val);
                if(flag==1)
                {
                    if(cur->left)
                        st.push(cur->left);
                    if(cur->right)
                        st.push(cur->right);
                }
                else
                {
                    if(cur->right)
                        st.push(cur->right);
                    if(cur->left)
                        st.push(cur->left);
                }
            }
            while(st.size())
            {
                q.push(st.top());
                st.pop();
            }
            res.push_back(vec);
            flag*=-1;
        }
        return res;
    }
};

有点难
复杂度O（n）

0 赞同 0 条回复

mpweixin用户永久会员 2023年6月26日下午7:05

//时间O(n) 空间O(n)
public List<List<Integer>> levelOrder(TreeNode root) {
    if(root == null){
        return new ArrayList();
    }

    List<List<Integer>> result = new ArrayList();
    Queue<TreeNode> queue = new LinkedList();

    queue.offer(root);
    int curLayer = 0;

    while(!queue.isEmpty()){

        int curSize = queue.size();
        curLayer++;
        List<Integer> curLayerResult = new LinkedList();

        for(int i = 0;i < curSize;i++){
            root = queue.poll();

            if(curLayer % 2 == 1){
                curLayerResult.add(root.val);
            }else{
                curLayerResult.add(0,root.val);
            }    

            if(root.left != null){
                queue.offer(root.left);
            }
            if(root.right != null){
                queue.offer(root.right);
            }
        }

        result.add(curLayerResult);
    }

    return result;
}

0 赞同 0 条回复

Ming 普通 2023年6月26日下午6:36

复杂度O(n) O(n)

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null) {
            return new ArrayList<>();
        }

        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> list = new ArrayList<>();
        int sum = 1;
        queue.offer(root);
        while(!queue.isEmpty()) {
            int k = queue.size();
            LinkedList<Integer> cur = new LinkedList<>();
            for(int i = 0; i < k; i++) {
                TreeNode node = queue.poll();
                if(sum % 2 != 0) {
                    cur.add(node.val);
                } else {
                    cur.addFirst(node.val);
                }
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            sum++;
            list.add(cur);
        }
        return list;
    }
}

0 赞同 0 条回复

残月冷骄阳普通 2023年6月26日下午5:05

解题方法

使用双端队列

复杂度

时间复杂度: $O(n)$
空间复杂度: $O(n)$

Code

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
ArrayList<List<Integer>> lists = new ArrayList<>();
        if (root == null){
            return  lists;
        }
        Queue<TreeNode> nodes = new LinkedList<>();
        nodes.offer(root);
        boolean isLeftOrder = true;
        while (!nodes.isEmpty()){
            LinkedList<Integer> res = new LinkedList<>();
            int size = nodes.size();
            for (int i = 0; i < size; i++) {
                TreeNode cur = nodes.poll();
                if (isLeftOrder){
                    res.addLast(cur.val);
                    if (cur.left != null){
                        nodes.offer(cur.left);
                    }
                    if (cur.right != null) {
                        nodes.offer(cur.right);
                    }
                }else {
                    res.addFirst(cur.val);
                    if (cur.left != null){
                        nodes.offer(cur.left);
                    }
                    if (cur.right != null) {
                        nodes.offer(cur.right);
                    }
                }
            }
            lists.add(res);

            if (isLeftOrder){
                isLeftOrder = false;
            }else {
                isLeftOrder = true;
            }

        }
        return lists;
    }
}

0 赞同 0 条回复

Dsjh 普通 2023年6月26日下午4:59

//c++ 队列，加了一个标志位
class Solution {
public:
    vector<vector<int>> ans;
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root){
            return ans;
        }
        deque<TreeNode*> q;
        q.push_back(root);
        // true 从左到右 false 从右到左
        bool f = true;
        while(!q.empty()){
            int num = q.size();
            vector<int> temp;
            while(num--){
                if(f){
                    TreeNode* t = q.front();
                    temp.push_back(t->val);
                    q.pop_front();
                    if(t->left) q.push_back(t->left);
                    if(t->right) q.push_back(t->right);
                }
                else{
                    TreeNode* t = q.back();
                    temp.push_back(t->val);
                    q.pop_back();
                    if(t->right) q.push_front(t->right);
                    if(t->left) q.push_front(t->left);
                }

            }
            ans.push_back(temp);
            f=!f;
        }
        return ans;
    }
};

0 赞同 0 条回复

雨落圆荷普通 2023年6月26日下午3:45

class Solution {
public List<List> levelOrder(TreeNode root) {
if(root null){
return new ArrayList<>();
}

    Queue<TreeNode> queue = new LinkedList<>();
    List<List<Integer>> res = new ArrayList<>();
    int sum = 1;
    queue.add(root);
    while(!queue.isEmpty()){
        int k = queue.size();
        LinkedList<Integer> tmp = new LinkedList<>();
        for(int i = 0; i < k; i++){
            TreeNode t = queue.poll();
            if(sum % 2 = = 1){
                tmp.add(t.val);
            } else {
                tmp.addFirst(t.val);
            }

            if(t.left != null) queue.add(t.left);
            if(t.right != null) queue.add(t.right);
        }
        res.add(tmp);
        sum ++;
    }

    return res;
}

}
时间复杂度：O(n)
额外空间复杂度：容器里最多存放 1/2 的节点，故为 O(n)

0 赞同 0 条回复

Yodl. 普通 2023年6月26日下午3:31

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(root == NULL)     return ans;
        bool flag=true;
        queue<TreeNode*> myQue;
        myQue.push(root);
        while(!myQue.empty()){
            vector<int> tmp;
            int size = myQue.size();
            for(;size--;myQue.pop()){
                TreeNode* node = myQue.front();
                if(node->left)      myQue.push(node->left);
                if(node->right)     myQue.push(node->right);               
                tmp.push_back(node->val);
            }
            if(flag==true)
            {
                ans.push_back(tmp);
                flag=false;
            }
            else
            {
                ans.push_back(vector<int>(tmp.rbegin(),tmp.rend()));
                flag=true;
            }
        }
        return ans;
    }
};
//时间复杂度O(n)  空间复杂度O(n)

0 赞同 0 条回复

【二叉树专题】剑指 Offer 32 – III. 从上到下打印二叉树

共以下 42 个回答

思路

代码

解题方法

复杂度

Code

# 回答此问题取消回复

【二叉树专题】剑指 Offer 32 – III. 从上到下打印二叉树

共以下 42 个回答

思路

代码

解题方法

复杂度

Code

# 回答此问题 取消回复

# 回答此问题取消回复