025-leetcode-树-二叉树的层序遍历

package tree;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

/**
 * 二叉树的层序遍历
 * 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
 *
 *  
 *
 * 示例：
 * 二叉树：[3,9,20,null,null,15,7],
 *
 *     3
 *    / \
 *   9  20
 *     /  \
 *    15   7
 * 返回其层序遍历结果：
 *
 * [
 *   [3],
 *   [9,20],
 *   [15,7]
 * ]
 *
 * 作者：力扣 (LeetCode)
 * 链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xnldjj/
 * 来源：力扣（LeetCode）
 * 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 *
 * */
public class LevelOrder {

    private static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }

        TreeNode(int val) {
            this.val = val;
        }
    }


    public static void main(String[] args) {
        TreeNode rootNode = new TreeNode(3);
        TreeNode node1 = new TreeNode(9);
        TreeNode node2 = new TreeNode(20);
        TreeNode node3 = new TreeNode(15);
        TreeNode node4 = new TreeNode(7);

        rootNode.left = node1;
        rootNode.right = node2;
        node2.left = node3;
        node2.right = node4;

        List<List<Integer>> lists = levelOrder(rootNode);
        System.out.println(" "+lists.toString());
        lists = levelOrderHelperNew(rootNode);
        System.out.println(" "+lists.toString());
    }

    private static List<List<Integer>> levelOrder(TreeNode rootNode){
        if (rootNode ==null){
            return new ArrayList<>();
        }
        List<List<Integer>> list = new ArrayList<>();
        if (rootNode.left== null && rootNode.right == null){
            List<Integer> subList = new ArrayList<>();
            subList.add(rootNode.val);
            list.add(subList);
            return list;
        }
        Deque<TreeNode> dequeue = new LinkedList<>();
        dequeue.push(rootNode);
        while (!dequeue.isEmpty()){
               int size = dequeue.size();
               ArrayList<Integer> subList = new ArrayList<>();
               while (size-->0){
                   TreeNode node = dequeue.pop();
                   subList.add(node.val);
                   if (node.left!=null){
                       dequeue.addLast(node.left);
                   }
                   if (node.right!=null){
                       dequeue.addLast(node.right);
                   }
               }
               list.add(subList);
        }
        return list;
    }


    private static List<List<Integer>> levelOrderHelperNew(TreeNode rootNode){
        List<List<Integer>> lists = new ArrayList<>();
        levelOrderHelper(lists, rootNode, 0);
        return lists;
    }

    // DFS
    // 根左右
    // list node level
    // 递归处理的时候要考虑终止条件 处理过程 和 递归操作 这三个部分 终止条件一般写在最前面
    private static void levelOrderHelper(List<List<Integer>> list, TreeNode rootNode, int level){
        if (rootNode == null){
            return;
        }
        if (level>=list.size()){ // = 的情况只在level=0的时候出现 其他都是 level>list.size()
            list.add(new ArrayList<>());
        }
        // 在新的一行中添加当前的元素
        list.get(level).add(rootNode.val);
        levelOrderHelper(list, rootNode.left, level+1);
        levelOrderHelper(list, rootNode.right, level+1);
    }


}

输出：

 [[3], [9, 20], [15, 7]]
 [[3], [9, 20], [15, 7]]