YOLO 普通 2024年3月28日下午1:23

 /*从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。 */
class Solution {
    public List<List<Integer>> decorateRecord(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> arr = new ArrayList<>();
            for(int i=0;i<k;i++){
                TreeNode t = queue.poll();
                arr.add(t.val);
                if(t.left != null){
                     queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }   
            }
            res.add(arr);
        }
        return res;
    }
}

0 赞同 0 条回复

NULL 普通 2024年3月20日下午8:52

/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<List> decorateRecord(TreeNode root) {
if(root null)return new ArrayList<>();
Queue queue = new LinkedList<>();
List<List> res = new ArrayList<>();

    queue.add(root);
    while(!queue.isEmpty()){
        int n = queue.size();
        List<Integer> tmp = new ArrayList<>();//用于存放一层的节点
        for(int i = 0; i < n; 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 条回复

kfaebot 普通 2024年3月14日下午9:25

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*>que;

        if(root!=nullptr){
            que.push(root);
        }

        while(!que.empty()){
            int size=que.size();
            vector<int> vec;
            for(int i=0;i<size;i++){
                TreeNode* tmp=que.front();
                que.pop();
                vec.push_back(tmp->val);

                if(tmp->left!=nullptr){
                    que.push(tmp->left);
                }
                if(tmp->right!=nullptr){
                    que.push(tmp->right);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};
//时间和空间复杂度均为O(N)

0 赞同 0 条回复

Let it be 永久会员 2024年3月12日下午10:15

class Solution {
public List<List> decorateRecord(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;
}
}时间空间复杂度O（n）

0 赞同 0 条回复

东普通 2024年3月12日下午8:28

//又是层序遍历
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> decorateRecord(TreeNode root) {
        if(root==null) {
            return new ArrayList<List<Integer>>();
        }

        List<List<Integer>> res = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        //将根节点放入队列中，然后不断遍历队列
        queue.add(root);
        while(queue.size()>0) {
            //获取当前队列的长度，这个长度相当于 当前这一层的节点个数
            int size = queue.size();
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            //将队列中的元素都拿出来(也就是获取这一层的节点)，放到临时list中
            //如果节点的左/右子树不为空，也放入队列中
            for(int i=0;i<size;++i) {
                TreeNode t = queue.remove();
                tmp.add(t.val);
                if(t.left!=null) {
                    queue.add(t.left);
                }
                if(t.right!=null) {
                    queue.add(t.right);
                }
            }
            //将临时list加入最终返回结果中
            res.add(tmp);
        }
        return res;
    }
}

0 赞同 0 条回复

　南木普通 2024年3月12日下午7:23

跟上一题差不多，这个需要遍历去除整层元素

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List> decorateRecord(TreeNode root) {
        if(root == null){
            return new ArrayList<>();
        }

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

        queue.add(root);
        while(!queue.isEmpty()){
            int k = queue.size();
            List 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 条回复

一个达不刘普通 2024年3月12日下午3:27

class Solution {
public:

vector<vector<int>> decorateRecord(TreeNode* root) {
    vector<vector<int>> arr;
    queue<TreeNode *> que;
    if(root != nullptr) que.push(root);


    while(!que.empty()){
        vector<int> tmp;//设置临时一维数组
        for(int i=que.size();i>0;i--){//循环每层的元素个数
            root = que.front();//队头出队
            que.pop();
            tmp.push_back(root->val);//插入临时数组
            if(root->left) que.push(root->left);
            if(root->right) que.push(root->right);
        }
        arr.push_back(tmp);
    }
    return  arr;   

}

};

0 赞同 0 条回复

RunAsOne 普通 2024年3月12日下午3:12

第n次打卡

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def decorateRecord(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: List[List[int]]
        """
        if not root:
            return []
        res = []
        queue = collections.deque()
        queue.append(root)
        while queue:
            r = []
            for _ in range(len(queue)):
                tmp = queue.popleft()
                r.append(tmp.val)
                if tmp.left:
                    queue.append(tmp.left)
                if tmp.right:
                    queue.append(tmp.right)
            res.append(r)
        return res

0 赞同 0 条回复

MARS 普通 2024年3月11日下午10:01

day8第二题

function decorateRecord(root: TreeNode | null): number[] {
    if(root == null) return []    
    let queue = [root],num=1  //用队列，num计算现在一层多少个节点
    let res = []
    while(queue.length>0){
        let count=0
        let level=[]
        while(num !=0){  //将该层全部元素全部拿出
            let node = queue.shift()
            level.push(node.val)
            if(node.left){
                queue.push(node.left)
                count++
            }
             if(node.right){
                queue.push(node?.right)
                count++
            }
            num--
        }
        num = count  //将下一层数目给到num
        res.push(level)
    }
    return res
};

0 赞同 0 条回复

叫不醒装睡的人普通 2024年3月11日下午9:31

class Solution {
    // 利用队列的先进先出特性实现层序遍历
    // 计算每一层的元素的个数
    public List<List<Integer>> decorateRecord(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> result = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            List<Integer> tempList = new LinkedList<>();
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                tempList.add(node.val);
            }
            result.add(tempList);
        }
        return result;
    }
    // 时间复杂度为 O(n)
    // 空间复杂度为 O(n)
}

0 赞同 0 条回复

言之命至普通 2024年3月11日下午9:13

```java
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();//k的个数代表一层
            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;
    }
}

时间复杂度：O（N）

“`

0 赞同 0 条回复

ChenZhangHangTime 永久会员 2024年3月11日下午8:30

这题比上一题难一点，主要是增加了一个temp列表，感觉这两道题思路虽然不算很复杂，但是代码写起来还是很难的
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<>();

    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 条回复

Free 普通 2024年3月11日下午8:05

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution 
{
public:
    vector<vector<int>> decorateRecord(TreeNode* root) 
    {
        vector<vector<int>> res;
        if(root == nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int qsize = q.size();
            vector<int> path;
            for(int i = 0; i < qsize; i++)
            {
                TreeNode* front = q.front();
                q.pop();
                path.push_back(front->val);
                if(front->left)
                    q.push(front->left);
                if(front->right)
                    q.push(front->right);
            }
            res.push_back(path);
            path.clear();
        }
        return res;
    }
};

时空复杂度O(n)

0 赞同 0 条回复

mpweixin用户普通 2024年3月11日下午2:27

public List<List> decorateRecord(TreeNode root) {
Queue q=new LinkedList<>();
List<List> res =new ArrayList<>();
if(root null) return res;
q.add(root);
while(!q.isEmpty()){
Listtem =new ArrayList<>();
for(int i=q.size();i>0;i–){
TreeNode node = q.poll();
tem.add(node.val);
if(node.left != null) q.add(node.left);
if(node.right != null) q.add(node.right);
}
res.add(tem);
}
return res;
}
思路：在借助队列的基础上将每一层的数据用临时arraList存起来通过q.size确定每一层的个数

0 赞同 0 条回复

南梁陈庆之普通 2024年3月11日上午11:32

与I类似，使用BFS遍历二叉树
时间复杂度：O（N），输入N数据，需要执行N次
空间复杂度：O（N）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> decorateRecord(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int n = queue.size();
            List<Integer> tempList = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.poll();
                tempList.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            list.add(tempList);
        }
        return list;
    }
}

0 赞同 0 条回复

神经蛙普通 2024年3月10日下午11:59

class Solution {
public:
vector<vector> decorateRecord(TreeNode* root) {
queue<TreeNode*> que; // 每次循环存放一层的节点
vector<vector> res;
if(root != NULL) que.push(root);
while(!que.empty()) {
vector tmp;
for(int i = que.size(); i > 0; –i) {
root = que.front();
que.pop();
tmp.push_back(root->val);
if(root->left != NULL) que.push(root->left);
if(root->right != NULL) que.push(root->right);
}
res.push_back(tmp);
}
return res;
}
};
打卡

0 赞同 0 条回复

helloMoon 普通 2024年3月10日下午11:34

II. 从上到下打印二叉树java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> decorateRecord(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 条回复

mpweixin用户普通 2024年3月10日下午9:43

java
class Solution {
public List<List> decorateRecord(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;
}
}
时间复杂度 O(N)
空间复杂度 O(N)

0 赞同 0 条回复

方铎码农普通 2024年3月10日下午5:21

class Solution {
    public List<List<Integer>> decorateRecord(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()){
            int n = queue.size();
            List<Integer> level = new ArrayList<>(n);
            for(int i = 0; i < n; i++){
                TreeNode node = queue.poll();
                level.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
            res.add(level);
        }

        return res;
    }
}

时间复杂度$O(n)$，这题注意在本层开始前，队列内都是本层节点，算队列长度就知道本层节点数，从而可以分层遍历

0 赞同 0 条回复

Jimmy 普通 2024年3月10日下午4:19

时间复杂度O(n)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> decorateRecord(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;
        if(root){
            que.push(root);
        }
        TreeNode *cur = nullptr;
        while(!que.empty()){
            vector<int> temAns;
            int size = que.size();
            for(int i=0;i<size;i++){
                cur = que.front();
                temAns.push_back(cur->val);
                que.pop();
                if(cur->left)que.push(cur->left);
                if(cur->right)que.push(cur->right);
            }
            ans.push_back(temAns);
        }
        return ans;
    }
};

0 赞同 0 条回复

白雪公主倒拔垂杨柳永久会员 2024年3月10日下午4:01

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);

        int i;
        while(!queue.isEmpty()){
            int size=queue.size(); //每层的大小
            List<Integer> t = new ArrayList<>();
            for(i=0;i<size;i++){
                TreeNode temp=queue.poll();
                t.add(temp.val); //把每层的内容放到t里面去
                if(temp.left!=null){
                    queue.add(temp.left);
                }
                if(temp.right!=null){
                    queue.add(temp.right);
                }
            }
            res.add(t); //List<Integer>放到List <List<Integer>> 里
        }

        return res;


    }
}

0 赞同 0 条回复

Yuki 永久会员 2024年3月10日上午10:48

层序遍历的变形

class Solution {
public:
vector<vector> decorateRecord(TreeNode* root) {
vector<vector>res;
queue<TreeNode*>que;
if(rootnullptr)return res;
que.push(root);

    while(!que.empty()){
        int size=que.size();
        vector<int>vec;

        for(int i=0;i<size;i++){
            TreeNode*tmp=que.front();
            vec.push_back(tmp->val);
            que.pop();

            if(tmp->left)que.push(tmp->left);
            if(tmp->right)que.push(tmp->right);
        }

        res.push_back(vec);
    }
    return res;

}

};

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

0 赞同 0 条回复

Thaddeus 永久会员 2024年3月10日上午9:35

打卡

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

        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int _size = que.size();
            vector<int> tmp;
            for(int i = 0; i < _size; ++i) {
                TreeNode* cur = que.front(); que.pop();
                tmp.emplace_back(cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            res.emplace_back(tmp);
        }
        return res;
    }
};

0 赞同 0 条回复

进取普通 2024年3月10日上午9:27

class Solution {
public:
vector<vector> decorateRecord(TreeNode* root) {
vector<vector> ret;
if (root nullptr) return ret;
queue<TreeNode*> que;
que.push(root);
while (!que.empty()){
int i = que.size();
vector tmp;
while (i > 0){
TreeNode *node = que.front();
que.pop();
tmp.push_back(node->val);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
–i;
}
ret.push_back(tmp);
}
return ret;
}
};时空复杂度O(N)

0 赞同 0 条回复

Yox 普通 2024年3月10日上午5:40

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

class Solution:
def decorateRecord(self, root: Optional[TreeNode]) -> List[List[int]]:
if not root:
return []
tmp = []
res = []
tmp.append(root)
while tmp:
tmpapd = []
for _ in range(len(tmp)):
cur = tmp.pop(0)
tmpapd.append(cur.val)
if cur.left: tmp.append(cur.left)
if cur.right: tmp.append(cur.right)
res.append(tmpapd)

    return res

双o n

0 赞同 0 条回复

=.= 普通 2024年3月9日下午11:51

/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<List> decorateRecord(TreeNode root) {
List<List> res = new LinkedList<>();
if(root null) return new LinkedList<>();

    Deque<TreeNode> queue = new ArrayDeque<>();
    queue.addLast(root);

    while(!queue.isEmpty()){
        int sz = queue.size();
        List<Integer> level = new LinkedList<>();
        for(int i=0; i<sz; i++){
            TreeNode node = queue.removeFirst();
            level.add(node.val);
            if(node.left != null) queue.addLast(node.left);
            if(node.right != null) queue.addLast(node.right);
        }
        res.add(level);
    }

    return res;
}

}

时空复杂度O(n)

0 赞同 0 条回复

heathhou 普通 2024年3月9日下午10:23

class Solution {
public:
    vector<vector<int>> decorateRecord(TreeNode* root) {
        vector<vector<int>> result;
        if(root == nullptr){
            return result;
        }
        queue<TreeNode*> q;
        q.push(root);

        while(!q.empty()){
            // 确定当前队列的元素个数，这个个数就是二叉树一层的节点个数
            int k = q.size();
            vector<int> v;
            for(int i = 0; i < k; ++i){
                auto t = q.front();
                q.pop();
                v.push_back(t->val);
                if(t->left)
                    q.push(t->left);
                if(t->right)
                    q.push(t->right);
            }
            result.push_back(v);
        }
        return result;
    }
};

0 赞同 0 条回复

云无深雁影普通 2024年3月9日下午10:19

class Solution {
public List<List> decorateRecord(TreeNode root) {
List<List> ans = new ArrayList<>();
if(root null) return ans;
Queue queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
List layer = new ArrayList<>();
int len = queue.size();
for(int i = 0; i < len; i++){
TreeNode temp = queue.remove();
layer.add(temp.val);
if(temp.left!=null) queue.add(temp.left);
if(temp.right!=null) queue.add(temp.right);
}
ans.add(layer);
}
return ans;

}
//时空复杂度均为On

0 赞同 0 条回复

机电皮怪永久会员 2024年3月9日下午9:42

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

“`C++
class Solution {
public:
vector> decorateRecord(TreeNode* root) {
if(root == nullptr)
{
return {};
}
vector> result;
vector res_sub;
queue sub;
sub.push(root);
while(sub.empty() != true)
{

        for(int i = 0, j = sub.size(); i < j; i++)
        {
            TreeNode* temp = sub.front();
            sub.pop();
            res_sub.push_back(temp->val);
            if(temp->left != nullptr)
            {
                sub.push(temp->left);
            }
            if(temp->right != nullptr)
            {
                sub.push(temp->right);
            }
        }
        result.push_back(res_sub);
        res_sub.clear();
    }

    return result;
}

};

“`

0 赞同 0 条回复

莫～慢～待普通 2024年3月9日下午8:18

class Solution {
public List<List> decorateRecord(TreeNode root) {
List<List> res=new ArrayList<>();
if(rootnull)
{
return res;
}
Queue queue=new LinkedList<>();
queue.offer(root);
int count=queue.size();
while(!queue.isEmpty())
{
List list_res=new ArrayList<>();
for(int i=0;i<count;i++)
{
TreeNode node=queue.poll();
list_res.add(node.val);
if(node.left!=null)
queue.offer(node.left);
if(node.right!=null)
queue.offer(node.right);
}
count=queue.size();
res.add(list_res);
}
return res;
}
}
层次遍历，记录每一层的遍历数量，单独用list存储。

0 赞同 0 条回复

Raphtalia. 普通 2024年3月9日下午7:43

class Solution {
public:
vector<vector> decorateRecord(TreeNode* root) {
queue<TreeNode> q;
vector<vector> ans;
if(!root) return ans;
q.push(root);
while(!q.empty()){
vector tmp;
for(int i = q.size(); i > 0; i –){//需要从过后往前
TreeNode cur = q.front();
q.pop();
tmp.push_back(cur->val);
if(cur->left != nullptr) q.push(cur->left);
if(cur->right != nullptr) q.push(cur->right);
}
ans.push_back(tmp);
}
return ans;
}
};

0 赞同 0 条回复

王位詮釋普通 2024年3月9日下午7:33

class Solution {
    public List<List<Integer>> decorateRecord(TreeNode root) {
        List<List<Integer>> results = new ArrayList<>();
        Deque<TreeNode> deque = new LinkedList<>();
        if(root!=null){
            deque.offer(root);
        }
        while(!deque.isEmpty()){
            List<Integer> result = new ArrayList<>();
            for(int i=deque.size();i>0;i--){
                TreeNode temp = deque.poll();
                result.add(temp.val);
                if(temp.left!=null){
                    deque.offer(temp.left);
                }
                if(temp.right!=null){
                    deque.offer(temp.right);
                }
            }
            results.add(result);
        }
        return results;
    }
}
思路：最开始时候如果root不为空的话就让其进入队列
随后如果队列为空的话就直接跳出循环
如果队列不为空的话，此时队列里的所有deque.size()个元素都是同一层的，打印的同时将队列中元素的非空子元素入队
时间复杂度：遍历了树的所有节点，O(n)
空间复杂度：O(n)

0 赞同 0 条回复

紫芝普通 2024年3月9日下午5:37

思路：层序遍历

func decorateRecord(root *TreeNode) [][]int {
    var res [][]int
    if root == nil { return res }
    que := []*TreeNode{root}
    for len(que) > 0 {
        n := len(que)
        var tmp []int
        for i := 0; i<n; i++ {
            cur := que[i]
            tmp = append(tmp, cur.Val)
            if cur.Left != nil { que = append(que, cur.Left) }
            if cur.Right != nil { que = append(que, cur.Right) }
        }
        res = append(res, tmp)
        que = que[n:]
    }
    return res
}

0 赞同 0 条回复

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

共以下 33 个回答

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

# 回答此问题取消回复

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

共以下 33 个回答

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

# 回答此问题 取消回复

# 回答此问题取消回复