原题
给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。
示例：
输入：[1,2,3,4,5,null,7,8]
1
/ \
2 3
/ \ \
4 5 7
/
8
输出：[[1],[2,3],[4,5,7],[8]]
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
vector<ListNode*> listOfDepth(TreeNode* tree) {
}
};
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/list-of-depth-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解题思路
这道题是一点都不会，但是没关系，只需要现学现做就好。
- 第一步：标注关键词
给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。
- 第二步：百度现学
- 第三步：看答案
即使了解了二叉树和链表的基本概念，但是还是不会转换成算法，因为从来没做过，所以直接看答案看看别人是怎么做的。
参考答案（1）
这块主要还是二叉树的层序遍历，另外在链表处理的时候，使用了dummy这样的虚拟节点，
使得代码相对简洁一些，不用考虑head了
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode[] listOfDepth(TreeNode tree) {
LinkedList<TreeNode> queue = new LinkedList<>();
queue.offer(tree);
List<ListNode> res = new ArrayList<>();
ListNode dummy = new ListNode(0);
while (!queue.isEmpty()) {
int size = queue.size();
ListNode curr = dummy;
for (int i = 0; i < size; i++) {
TreeNode treeNode = queue.poll();
curr.next = new ListNode(treeNode.val);
if (treeNode.left != null) {
queue.offer(treeNode.left);
}
if (treeNode.right != null) {
queue.offer(treeNode.right);
}
curr = curr.next;
}
res.add(dummy.next);
dummy.next = null;
}
return res.toArray(new ListNode[] {
});
}
}
作者：fisher12
链接：https://leetcode-cn.com/problems/list-of-depth-lcci/solution/ceng-xu-bian-li-by-fisher12/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
LinkedList中add/offer、remove/poll、element/peek区别
二叉树java代码创建
运行结果：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
/**
* 单链表
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
/**
* 二叉树
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public static ListNode[] listOfDepth(TreeNode tree) {
LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(tree);
List<ListNode> res = new ArrayList<ListNode>();
ListNode dummy = new ListNode(0);
while (!queue.isEmpty()) {
int size = queue.size();
ListNode curr = dummy;
for (int i = 0; i < size; i++) {
TreeNode treeNode = queue.poll();
curr.next = new ListNode(treeNode.val);
if (treeNode.left != null) {
queue.offer(treeNode.left);
}
if (treeNode.right != null) {
queue.offer(treeNode.right);
}
curr = curr.next;
}
res.add(dummy.next);
dummy.next = null;
}
//最后把结果列表转换为数组返回
//所以这个算法实际做的是把二叉树遍历，把值放到列表里再生成数组返回
//核心在于遍历
return res.toArray(new ListNode[] {
});
}
public static void main(String[] args) {
TreeNode tA = new TreeNode(1);
TreeNode tB = new TreeNode(2);
TreeNode tC = new TreeNode(3);
TreeNode tD = new TreeNode(4);
TreeNode tE = new TreeNode(5);
TreeNode tF = new TreeNode(7);
TreeNode tG = new TreeNode(8);
/**
* A
* B C
* D E F G
*/
tA.left = tB;
tA.right = tC;
tB.left= tD;
tB.right = tE;
tC.left =tF;
tC.right = tG;
//现在只要把tA放入算法，就能得出结果了。
ListNode[] listNodes = listOfDepth(tA);
for (ListNode listNode : listNodes) {
int i = 1;
ListNode curr = listNode;
if (curr.next == null){
System.out.print("--- "+listNode.val);
}else {
while (curr.next != null){
if (i == 1){
System.out.print("--- "+curr.val);
i = 0;
}else {
curr = curr.next;
System.out.print(" "+curr.val+" ");
}
}
}
System.out.println("");
}
}
}
期望输出：
--- 1
--- 2 3
--- 4 5 7 8