树问题之节点收集问题

声明：本博客记录的题目全部来自于力扣，对这些题目进行整理的人为花花酱以及他的个人网站，本博客主要用来记录自己的算法学习的笔记。

102.二叉树的层序遍历

问题描述请点击大标题跳转

解题思路

首先我们将树的层划分出来，这个学没学过的人一眼就会

很简单的分层，第一层可以直接访问第二层，第二层可以直接访问第三层，只能从上往下。

现在我们回忆一下，当我们在进行二叉树的前序、中序、后续遍历的时候，我们都是每次只向下看一个节点，然后再根据存储节点值，而且除了使用递归的方法还有栈的方法。

但是这个问题很显然我们要先收集完全部下面的节点，储存好值，再收集下面一层所有的节点。

仔细想这两者的区别，其实就是深度优先和广度优先的区别，所以这题我们使用广度优先。而广度优先要使用到的数据结构就是：队列。

现在我们要做的就是将上面的树转换成这样的队列

大致描述就是：
头节点入队
头节点出队，存贮节点值
头节点左右孩子入队
左孩子出队，存储节点值
左孩子左右孩子入队
右孩子出队，存储节点值
右孩子左右节点入队
。。。
发现这里面是有循环的，直接用循环来解决
还要解决的一个问题是空值问题，如果是空就不入队了

代码编写

/**
 * 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>> levelOrder(TreeNode root) {
        List<List<Integer>> theTree = new ArrayList<>();

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

        //节点队列，用来收集节点
        Queue<TreeNode> queue = new LinkedList<>();
        //头节点先入队
        queue.offer(root);
        //进入循环
        while(!queue.isEmpty()){
            List<Integer> level = new ArrayList<>();
            int size = queue.size();
            //左右节点入队
            for(int i = 0; i <size; i++){
                TreeNode node = queue.poll();
                level.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            theTree.add(new ArrayList(level));
        }
        return theTree;
    }
}

107.二叉树的层序遍历二

问题描述请点击大标题跳转

解题思路

这题和上面那题有所不同的地方就是，要反正来输出，从底向上。

那这个解题思路就只要用到java的集合框架的一个特性就行，这也是一个小细节，那就是在将层数据List加入到结果的List的时候，妙用add

我们先返回到上面的代码

theTree.add(new ArrayList(level));

这里的add默认的就是往后加，进行一个数组的扩充，这个大家都理解。

那下面就展示一下add带下标和不带下标的区别

测试代码是

public void testAdd(){
        int[] arr = {1,2,3,4,5};
        //这段代码是将整形数组转为ArrayList
        ArrayList<Integer> arrayList = (ArrayList<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toList());
         /**
         *  也可以使用这种方式，但这个就是用类来实现数组
         *  Integer[] arr = {1,2,3,4,5};
         *  ArrayList<Integer> arrayList = (ArrayList<Integer>) Arrays.asList(arr);
         */
        arrayList.add(6);
        System.out.println(arrayList);
        arrayList.add(0,7);
        System.out.println(arrayList);
    }

那这样我们可以直接使用上面的代码，只要在加入的时候稍作修改

代码编写

/**
 * 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>> levelOrder(TreeNode root) {
        List<List<Integer>> theTree = new ArrayList<>();

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

        //节点队列，用来收集节点
        Queue<TreeNode> queue = new LinkedList<>();
        //头节点先入队
        queue.offer(root);
        //进入循环
        while(!queue.isEmpty()){
            List<Integer> level = new ArrayList<>();
            int size = queue.size();
            //左右节点入队
            for(int i = 0; i <size; i++){
                TreeNode node = queue.poll();
                level.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            theTree.add(0, new ArrayList(level));
        }
        return theTree;
    }
}

429.N叉树的层序遍历

问题描述请点击大标题跳转

解题思路

这个题目我在我的博客N叉树的三种遍历中已经很详细的写过了，思维和上面的也是一样的，就是还是用到了一个特殊的方法addAll，这个方法非常的有意思，当然也是可以使用循环来代替的，如果想看详细讲解请移步到那个博客。

代码编写

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> lists = new ArrayList<List<Integer>>();

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

        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> levelList = new ArrayList<>();
            int size = queue.size();
            for(int i = 0; i < size; i++){
                Node node = queue.poll();
                levelList.add(node.val);
                queue.addAll(node.children);
            }
            lists.add(levelList);
        }
        return lists;
    }
}

872.叶子相似的树

问题描述请点击大标题跳转

解题思路

上面的题目都是要收集所有的节点，但这题的意思是只要收集最后的节点。

那最后的节点有什么特征？就是没有左子树和又子树。理解这个就好办，现在就去收集两个树的最后的节点，并且按照从左到右的顺序，比较即可

这里我收集节点就使用深度优先的方法

代码编写

/**
 * 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 boolean leafSimilar(TreeNode root1, TreeNode root2) {
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();

        dfs(root1,list1);
        dfs(root2,list2);

        return list1.equals(list2);
    }
    public void dfs(TreeNode root,List<Integer> list){
        if(root.left == null && root.right == null){
            list.add(root.val);
        }
        if(root.left != null){
            dfs(root.left,list);
        }
        if(root.right != null){
            dfs(root.right,list);
        }
    }
}