LeetCode_102：二叉树的层序遍历

1、题目描述：

2、思路分析：

3、算法实现：

为了能够验证输出结果，所以写了一个Node类和Main类

（1）节点类：

public class Node {
    int val;
    Node left;
    Node right;
    Node(int val){
        this.val = val;
    }
}

（2）二叉树类：

public class Solution {
    public Node root;

    public void setRoot(Node root) {
        this.root = root;
    }

    //层序遍历
    public List<List<Integer>> levelOrder(Node root) {

        List<List<Integer>> list = new ArrayList<>();

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

        Queue<Node> queue = new LinkedList<>();
        //将根节点入队
        queue.offer(root);

        while (!queue.isEmpty()) {

            List<Integer> tempList = new ArrayList<>();
            int len = queue.size();

            for (int i = 0; i <= len-1; i++) {
                //将队中的节点出队并放入tempList中
                Node node = queue.poll();
                tempList.add(node.val);
                
                //将根节点的左节点放入队列
                if (node.left != null) {
                    queue.add(node.left);
                }
                //将根节点的右节点放入队列
                if (node.right != null) {
                    queue.add(node.right);
                }
            }

            //将tempList放入list中
            list.add(tempList);
        }
        return list;
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        Node node = new Node(3);
        Node node1 = new Node(9);
        Node node2 = new Node(20);
        Node node3 = new Node(15);
        Node node4 = new Node(7);

        Solution binaryTree = new Solution();

        binaryTree.setRoot(node);
        node.left = node1;
        node.right = node2;
        node2.left = node3;
        node2.right = node4;

        List<List<Integer>> lists = binaryTree.levelOrder(node);
        System.out.println(lists);
    }
}

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

4、LeedCode解答：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
    
        Queue<TreeNode> queue = new LinkedList<>();
        //将根节点入队
        queue.offer(root);

        while (!queue.isEmpty()) {
            List<Integer> tempList = new ArrayList<>();
            int len = queue.size();
            for (int i = 0; i < len; i++) {
                //将队中的节点出队并添加到tempList中
                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中
            list.add(tempList);
        }
        return list;
    }
}