【二叉树专题】剑指 Offer 32 – II. 从上到下打印二叉树-跟着帅地玩副业，开拓第二曲线PlayOffer

hi 普通 2023年8月9日上午10:42

vector 里套vector
每一层vector中的数量由队列中节点的个数决定（上一步加入的左、右节点）

/**
 * 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;
        queue<TreeNode*> q;
        if(root) q.push(root);

        while(q.size())
        {
            vector<int> level;
            int len = q.size();

            while(len--){
                TreeNode* t = q.front();
                level.push_back(t->val);
                q.pop();
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
            }
            res.push_back(level);
        }
        return res;
    }
};

0 赞同 0 条回复

今天没时间刷题普通 2023年8月1日下午11:14

时间On，空间On
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root) return res;

        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int num = q.size();
            vector<int> tempVec;
            while(num--)
            {
                TreeNode* temp = q.front();
                q.pop();
                tempVec.push_back(temp->val);
                if(temp->left) q.push(temp->left);
                if(temp->right) q.push(temp->right);
            }
            res.push_back(tempVec);
        }
        return res;
    }
};

0 赞同 0 条回复

朱志刚普通 2023年7月31日下午3:52

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root)return res;
        queue<TreeNode*> temp;
        temp.push(root);

        while(!temp.empty())
        {
            int k=temp.size();
            vector<int> t;
            for(int i=0;i<k;i++)
            {
                auto m=temp.front();
                temp.pop();
                t.push_back(m->val);
                if(m->left)temp.push(m->left);
                if(m->right)temp.push(m->right);



            }
            res.push_back(t);
        }
        return res;
    }
};

通过

0 赞同 0 条回复

小季同学普通 2023年7月26日下午10:33

ts

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function levelOrder(root: TreeNode | null): number[][] {
    // 边界判断
    if(!root) return []
    // 队列遍历
    const queue: TreeNode[] = []
    const result: number[][] = []
    queue.push(root)
    while(queue.length > 0) {
        let level: number[] = []
        let levelSize = queue.length
        for(let i = 0; i < levelSize; i++) {
            const p = queue.shift()!
            level.push(p.val)
            if(p.left) {
                queue.push(p.left)
            }
            if(p.right) {
                queue.push(p.right)
            }
        }
        result.push(level)
    }
    return result
};

0 赞同 0 条回复

doordie. 普通 2023年7月21日下午4:55

    public int[] levelOrderDFS(TreeNode root) {
        //辅助栈
        Stack<TreeNode> stack = new Stack<>();
        //辅助节点
        TreeNode node = root;
        while (node != null || !stack.isEmpty()){
            //迭代访问节点的左孩子
            while (node != null) {
                //入栈
                stack.push(node);
                node = node.left;
            }
            if (!stack.isEmpty()){
                //出栈
                node = stack.pop();
                System.out.println(node.val);
                node = node.right;
            }
        }
        return  new int[0];
    }

这是一个非递归的中序遍历打印

0 赞同 0 条回复

今天你刷题了嘛普通 2023年7月19日下午10:12

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null) return result;
        queue.offer(root);
        while(!queue.isEmpty()){
            // 使用k来记录栈中元素个数（即某一层的节点数）
            // 然后取出k个节点，并处理(需要一个循环来控制一层的结点数)
            int k = queue.size();
            List<Integer> cur = new ArrayList<>();
            while(k!=0){
                TreeNode temp = queue.poll();
                k--;
                cur.add(temp.val);
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
            result.add(cur);
        }
        return result;
    }
}

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

0 赞同 0 条回复

北辰普通 2023年7月18日下午8:26

public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> ans = new ArrayList<>();
            if(root==null) return ans;
            Queue<TreeNode> q = new LinkedList<>();
            q.offer(root);
            List<Integer> list = new ArrayList<>();
            list.add(root.val);
            ans.add(list);

            while(!q.isEmpty()) {
                int size = q.size();
                List<Integer> temp = new ArrayList<>();
                while(size-->0) {
                    TreeNode node = q.poll();
                    if(node.left!=null) {
                        q.offer(node.left);
                        temp.add(node.left.val);
                    }
                    if(node.right!=null) {
                        q.offer(node.right);
                        temp.add(node.right.val);
                    }
                }
                if(temp.size()>0) {
                    ans.add(temp);
                }
            }
            return ans;
    }

时间复杂度：O（n）
空间复杂度：O（n）

0 赞同 0 条回复

片言莫语普通 2023年7月18日下午7:20

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.add(root); // 将根节点入队
        while(!queue.isEmpty()){
            int k = queue.size(); // 获取当前层的节点数量
            List<Integer> tmp = new ArrayList<>(); // 创建一个临时列表，用于存储当前层的节点值
            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); // 如果节点的右子节点不为空，将右子节点入队
            }
            res.add(tmp); // 将当前层的节点值列表添加到结果列表中
        }

        return res; // 返回层序遍历的结果
    }
}

0 赞同 0 条回复

Mby 普通 2023年7月18日下午2:22

/**
 * 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) {
        if(root == null){
            return new ArrayList<>();
        }

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

        queue.add(root);
        while(!queue.isEmpty()){
            int k = queue.size();
            List<Integer> tmp = new ArrayList<>();
            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);
            }
            res.add(tmp);
        }
        return res;
    }
}

0 赞同 0 条回复

ppopp 普通 2023年7月18日上午1:10

/**
* 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> levelOrder(TreeNode root) {
vector<vector> ret;
if(!root) return ret;
queue<TreeNode*> q;
q.push(root);
while(!q.empty()){
int lz = q.size();
ret.push_back(vector());
for(int i = 1; i <= lz; ++i){
auto node = q.front();
q.pop();
ret.back().push_back(node->val);//back()表示对最后一个元素的引用
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
}
return ret;
}
};

0 赞同 0 条回复

普通 2023年7月17日下午11:04

c++ 代码在之前一题的基础上改进一些就可以了
class Solution
{
vector<vector> cc;
queue<TreeNode> Inqueue;
public:
vector<vector> levelOrder(TreeNode root)
{
if(!root) return cc;
Inqueue.push(root);
while(Inqueue.size())
{
int l=Inqueue.size();
vector lever;
for(int i=0;i<l;i++)
{
TreeNode* temp=Inqueue.front();
lever.push_back(temp->val);
if(temp->left) Inqueue.push(temp->left);
if(temp->right) Inqueue.push(temp->right);
Inqueue.pop();
}
cc.push_back(lever);
}
return cc;
}
};

0 赞同 0 条回复

CKX 普通 2023年7月17日下午6:14

func levelOrder(root *TreeNode) [][]int {
    res := [][]int{}
    queue := []*TreeNode{}

    if root == nil {
        return res
    }

    //将根节点加入队列中
    queue = append(queue, root)

    for i := 0; len(queue) > 0; i++ {
        length := len(queue)    //临时长度
        temp := []int{}
        for j := 0; j < length; j++ {
            temp = append(temp, queue[0].Val)
            if queue[0].Left != nil {
                queue = append(queue, queue[0].Left)
            }
            if queue[0].Right != nil {
                queue = append(queue, queue[0].Right)
            }
            queue = queue[1:]
        }
        res = append(res, temp)
    }

    return res

}

时间O(n)
空间O(n)

0 赞同 0 条回复

June 普通 2023年7月17日下午5:20

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    var ans [][]int
    if root == nil {
        return ans
    }

    var queue = list.New()
    queue.PushBack(root)

    for queue.Len() != 0 {
        size := queue.Len()
        var tmp []int // 中间数组
        for i:=0 ; i < size ; i++ {
            var node *TreeNode = queue.Front().Value.(*TreeNode)
            queue.Remove(queue.Front())
            tmp = append(tmp,node.Val)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }

            if node.Right != nil {
                queue.PushBack(node.Right)
            }
        }
        ans = append(ans,tmp)
    }
    return ans
}

0 赞同 0 条回复

艺普通 2023年7月17日下午4:33

“`c++
//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
vector> levelOrder(TreeNode* root) {
vector> res;
int i;
if(!root) return res;
queue q;
q.push(root);
while(!q.empty())
{
int k=q.size();
vector lev;
for(i=0;ival);
if(tmp->left) q.push(tmp->left);
if(tmp->right) q.push(tmp->right);
}
res.push_back(lev);
}
return res;
}
};
“`

0 赞同 0 条回复

NullPointerException 普通 2023年7月17日下午3:10

class Solution {//遍历
public List<List> levelOrder(TreeNode root) {
List<List> reuslt =new ArrayList<List>();
List temp ;
if(root null) return reuslt;
Queue queue =new LinkedList();
queue.add(root);
int i= 1;
while(!queue.isEmpty())
{
i =queue.size();
temp =new ArrayList();
while(i>0)
{
TreeNode node =queue.remove();
i–;
if(node.left!=null)
{
queue.add(node.left);
}
if(node.right!=null)
{
queue.add(node.right);
}
temp.add(node.val);
}
reuslt.add(temp);
}
return reuslt;
}
}

0 赞同 0 条回复

V2ero 普通 2023年7月17日上午10:01

时间复杂度O（n）,空间复杂度O（n）

function levelOrder(root: TreeNode | null): number[][] {
     if (!root) return [];
    const queue: Array<TreeNode | null> = [root];
    const res: number[][] = [];
    while (queue.length) {
        const len = queue.length;
        const lev: number[] = [];
        for (let i = 0; i < len; i += 1) {
            const node = queue.shift();
            lev.push(node?.val);
            node?.left && queue.push(node.left);
            node?.right && queue.push(node.right);
        }
        res.push(lev);
    }
    return res;
};

0 赞同 0 条回复

土豆芋泥包_ 普通 2023年7月16日下午9:52

打卡

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.add(root);
        while(!queue.isEmpty()){
            int k = queue.size();
            List<Integer> tmp = new ArrayList<>();
            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);
            }
            res.add(tmp);
        }
        return res;
    }
}

0 赞同 0 条回复

神经蛙普通 2023年7月16日下午3:38

/**
    时间复杂度O(n)
    空间复杂度O(n)
*/
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        LinkedList<TreeNode> queue = new LinkedList<>();

        if (root == null) {
            return res;
        }      

        // 入队
        queue.add(root);

        // 处理每一层
        while(!queue.isEmpty()) {
            LinkedList<TreeNode> tmpQueue = new LinkedList<>();
            LinkedList<Integer> tmp = new LinkedList<>();
            // 处理一层
            while(!queue.isEmpty()) {
                TreeNode node = queue.removeFirst();
                tmp.add(node.val);
                if (node.left != null) {
                    tmpQueue.add(node.left);
                }
                if (node.right != null) {
                    tmpQueue.add(node.right);
                }
            }

            queue = tmpQueue;
            res.add(tmp);
        }

        return res;
    }
}

0 赞同 0 条回复

Marshan 普通 2023年7月16日上午11:59

略显繁琐

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root){
            return res;
        }
        queue<pair<TreeNode *,int>>nodeQueue;//second存储层数
        nodeQueue.push(make_pair(root,0));
        int index = 0;
        vector<int> tmpRes;
        while(!nodeQueue.empty()){
            pair<TreeNode *,int> tmp = nodeQueue.front();
            nodeQueue.pop();
            if(index != tmp.second){
                res.push_back(tmpRes);
                tmpRes.clear();
                index = tmp.second;
                tmpRes.push_back(tmp.first->val);
            }
            else{
                tmpRes.push_back(tmp.first->val);
            }
            // res[tmp.second].push_back(tmp.first->val);
            if(tmp.first->left){
                nodeQueue.push(make_pair(tmp.first->left,tmp.second+1));
            }
            if(tmp.first->right){
                nodeQueue.push(make_pair(tmp.first->right,tmp.second+1));
            }
        }
        res.push_back(tmpRes);
        return res;
    }
};

0 赞同 0 条回复

人生何处不青山普通 2023年7月16日上午10:28

TS模拟队列

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function levelOrder(root: TreeNode | null): number[][] {
    const queue: TreeNode[] = [];
    let hh = 0, tt = -1;
    const res: number[][] = [];
    if (root) queue[++tt] = root;
    while (hh <= tt) {
        let len = tt - hh + 1;
        let tmp:number[] = [];
        while (len--) {
            let cur = queue[hh++];
            tmp.push(cur.val);
            (cur.left) && (queue[++tt] = cur.left);
            (cur.right) && (queue[++tt] = cur.right);
        }
        (tmp.length) && (res.push(tmp));
    }
    return res;
};

0 赞同 0 条回复

波雅汉库克普通 2023年7月16日上午10:07

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == nullptr){
            return res;
        }
        deque<TreeNode*> dq;
        dq.push_back(root);
        while(!dq.empty()){
            vector<int> level;
            int len = dq.size();
            while(len--){
                TreeNode* cur = dq.front();
                dq.pop_front();
                if(cur->left){
                    dq.push_back(cur->left);
                }
                if(cur->right){
                    dq.push_back(cur->right);
                }
                level.push_back(cur->val);
            }
            res.push_back(level);
        }
        return res;
    }
};

时间：o(n)
空间：o(n)

0 赞同 0 条回复

周小二普通 2023年7月16日上午2:52

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        if(root != null) {
            queue.add(root);
        }
        while(!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            //循环此层层数并打印
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            result.add(tmp);
        }
        return result;
    }
}

0 赞同 0 条回复

阿尚普通 2023年7月16日上午12:05

//要求按层打印
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null) return result;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
            int layerSize = queue.size();
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < layerSize; i++){
                TreeNode node = queue.poll();
                list.add(node.val);

                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            result.add(list);
        }

        return result;
    }
}

0 赞同 0 条回复

长河呼叫黄江普通 2023年7月15日下午10:06

Day8：下面是代码

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> q = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();    
        if(root != null) q.offer(root);
        while(!q.isEmpty()){
            ArrayList<Integer> tmp = new ArrayList<>(); 
            for(int i = q.size(); i > 0; i--){
                TreeNode node = q.poll();
                tmp.add(node.val);
                if(node.left != null) q.offer(node.left);
                if(node.right != null) q.offer(node.right);
            }
            res.add(tmp);
        }    
        return res;
    }
}

0 赞同 0 条回复

CaCO3 永久会员 2023年7月15日下午9:11

”’java
class Solution {
public List<List> levelOrder(TreeNode root) {
List<List> re = new ArrayList<>();
if(root null){

        return re;
    }
    Queue<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    while(!queue.isEmpty()){
        int size = queue.size();
        List<Integer> list = new ArrayList<>();
        for(int i = 0;i < size;i++){
            TreeNode node = queue.poll();
            list.add(node.val);
            if(node.left != null){
                queue.offer(node.left);
            }
            if(node.right != null){
                queue.offer(node.right);
            }
        }
        re.add(list);
    }
    return re;
}

}
”’
时间复杂度O(n)
空间复杂度O(n)

0 赞同 0 条回复

#00456B 普通 2023年7月15日下午7:08

思路

和上一题类似，需要层序遍历，但是改为每一层分别用一个vector来存储。
所以在判断queue是否为空之后，先获取当前queue中的节点个数，这个数量表示这一层需要添加左右子节点的节点数，然后根据这个size数量来进行循环，将每一层的vector都push到ans中。最后输出ans。

代码

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(root == NULL){
            return ans;
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            vector<int> res;
            int size = que.size();
            while(size--){
                TreeNode* temp = que.front();
                res.push_back(temp->val);
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
                que.pop();
            }
            ans.push_back(res);
        }
        return ans;
    }
};

0 赞同 0 条回复

Luminous 普通 2023年7月15日下午6:08

/**
 * 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) {
        if(root==null) return new ArrayList<>();
        Queue<TreeNode> q=new LinkedList<>();
        List<List<Integer>> list=new ArrayList<>();
        q.add(root);
        while(!q.isEmpty()){
            List<Integer> tmp=new ArrayList<>();
            for(int i=q.size();i>0;i--){
                TreeNode node=q.poll();
                tmp.add(node.val);
                if(node.left!=null) q.add(node.left);
                if(node.right!=null) q.add(node.right);
            }
            list.add(tmp);
        } 
        return list;
    }
}

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

0 赞同 0 条回复

AD钙奶普通 2023年7月15日下午5:11

每一层都打印

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if(root == null) return new ArrayList<>();
        deque.addLast(root);
        while(!deque.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = deque.size();
            for(int i = 0; i < size; i ++) {
                TreeNode node = deque.removeFirst();
                list.add(node.val);
                if(node.left != null) deque.addLast(node.left);
                if(node.right != null) deque.addLast(node.right);
            }
            res.add(list);
        }
        return res;
    }
}

时间空间复杂度O(n)

0 赞同 0 条回复

Mooby 普通 2023年7月15日下午3:54

八
/**
* 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> levelOrder(TreeNode root) {
Queue queue = new LinkedList<>();
List<List> res = new ArrayList<>();
if (root != null) queue.add(root);
while (!queue.isEmpty()) {
List tmp = new ArrayList<>();
for (int i = queue.size(); i > 0; i–) {
TreeNode node = queue.poll();
tmp.add(node.val);
if (node.left != null) queue.add(node.left);
if (node.right != null) queue.add(node.right);
}
res.add(tmp);
}
return res;
}
}

0 赞同 0 条回复

枫梓。普通 2023年7月15日下午3:17

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> ans;
        if(!root) return ans;
        que.push(root);
        while(!que.empty()) {
            vector<int> layer;
            int size = que.size();
            for(int i = 0; i < size; ++i) {
                TreeNode* temp = que.front();
                que.pop();
                layer.push_back(temp->val);
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
            ans.push_back(layer);
        }
        return ans;
    }
};

双O(n)

0 赞同 0 条回复

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

共以下 30 个回答

思路

代码

# 回答此问题取消回复

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

共以下 30 个回答

思路

代码

# 回答此问题 取消回复

# 回答此问题取消回复