Offer 驾到，掘友接招！我正在参与2022春招打卡活动，点击查看活动详情。
一、题目描述：
题目来源：LeetCode-特定深度节点链表
给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。
示例：
输入：[1,2,3,4,5,null,7,8]
1
/ \
2 3
/ \ \
4 5 7
/
8
输出：[[1],[2,3],[4,5,7],[8]]
二、思路分析：
思路一：
通过层次遍历将每一层的节点加入到队列中，并每次对队列进行遍历。
比如将1送入队列之后，获取此时队列的长度，根据长度进行遍历。
第一次遍历1，并且将2,3加入队列。此时队列的长度为2，根据长度2进行遍历，再将4、5、7加入队列中。根据长度3进行遍历
将每次遍历的节点通过链表的方式连接起来，最后将头结点加入到一个容器中。
每次声明头结点后，还要声明一个辅助节点，用来连接链表
最后将链表加入到一个ArrayList中，或者是一开始就将数的高度求出来，只声明一个数组即可。
最后对ArrayList进行遍历一次将头结点加入到数组中。
思路二： 定义树深度为deep，同一个深度的保存到同一个ListNode
思路三： 层序遍历树中每层节点
每层节点生成一个链表
三、AC 代码：
思路一：
class Solution {
public ListNode[] listOfDepth(TreeNode tree) {
Queue<TreeNode> treeCopyQueen = new LinkedList<>();
if (tree != null) {
treeCopyQueen.add(tree);
}
List<ListNode> rel = new ArrayList<>();
int i = 0;
while (!treeCopyQueen.isEmpty()) {
int size = treeCopyQueen.size();
ListNode listNode = null;
ListNode tempNode = null;
for (int j = 0; j < size; j++) {
TreeNode popNode = treeCopyQueen.poll();
if (listNode == null) {
listNode = new ListNode(popNode.val);
tempNode = listNode;
} else {
ListNode temptempNode = new ListNode(popNode.val);
tempNode.next = temptempNode;
tempNode = temptempNode;
}
if (popNode.left != null) treeCopyQueen.add(popNode.left);
if (popNode.right != null) treeCopyQueen.add(popNode.right);
}
rel.add(listNode);
}
ListNode[] result = new ListNode[rel.size()];
for (int k = 0; k < rel.size(); k++) {
result[k] = rel.get(k);
}
return result;
}
public int treeNodeHeight(TreeNode root) {
if (root == null) return 0;
int leftH = treeNodeHeight(root.left);
int rightH = treeNodeHeight(root.right);
return leftH > rightH ? (leftH + 1) : (rightH + 1);
}
}
思路二：
class Solution {
public ListNode[] listOfDepth(TreeNode tree) {
List<ListNode> list = new ArrayList<>();
dfs(list, tree, 1);
ListNode[] arr = new ListNode[list.size()];
for (int i = 0; i < arr.length; i++) {
arr[i] = list.get(i);
}
return arr;
}
private void dfs(List<ListNode> nodeList, TreeNode node, int deep) {
if (node == null) return;
if (deep > nodeList.size()) nodeList.add(new ListNode(node.val));
else {
ListNode tempNode = nodeList.get(deep - 1);
while (tempNode.next != null) {
tempNode = tempNode.next;
}
tempNode.next = new ListNode(node.val);
}
dfs(nodeList, node.left, deep + 1);
dfs(nodeList, node.right, deep + 1);
}
}
思路三：
class Solution {
public ListNode[] listOfDepth(TreeNode tree) {
List<ListNode> listNode = new ArrayList<>();
Queue<TreeNode> queueNodes = new LinkedList<>();
queueNodes.add(tree);
while (!queueNodes.isEmpty()) {
int size = queueNodes.size();
ListNode leftNode = new ListNode();
for (int i = 0; i < size; i++) {
TreeNode tempNode = queueNodes.poll();
leftNode.next = new ListNode(tempNode.val);
leftNode = leftNode.next;
if (tempNode.left != null) queueNodes.offer(tempNode.left);
if (tempNode.right != null) queueNodes.offer(tempNode.right);
if (i == 0) listNode.add(leftNode);
}
}
return listNode.toArray(new ListNode[0]);
}
}
