LeetCode - 107. 二叉树的层次遍历 II

107. 二叉树的层次遍历 II

import java.util.*;


class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
}

public class Solution {

    private void reverse(List<List<Integer>> list) {
        if (Objects.isNull(list) || list.size() == 0) {
            return;
        }

        int size = list.size();
        int m = size >> 1;

        for (int i = 0;i < m; ++ i) {
            List t = list.get(i);
            list.set(i, list.get(size - i - 1));
            list.set(size - i - 1, t);
        }
    }

    private void add(List<List<Integer>> list, int index, int val) {
        int size = list.size();
        if (index == size) {
            List<Integer> treeNodes = new ArrayList<>();
            list.add(treeNodes);
        }
        list.get(index).add(val);
    }

    @SuppressWarnings("all")
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();

        if (Objects.isNull(root)) {
            return result;
        }

        LinkedList<NodeData> queue = new LinkedList<>();
        NodeData node = new NodeData(root, 0);
        queue.add(node);

        while (! queue.isEmpty()) {
            node = queue.poll();
            TreeNode treeNode = node.treeNode;

            add(result, node.deep, treeNode.val);

            if (Objects.nonNull(treeNode.left)) {
                NodeData leftNode = new NodeData(treeNode.left, node.deep + 1);
                queue.add(leftNode);
            }

            if (Objects.nonNull(treeNode.right)) {
                NodeData rightNode = new NodeData(treeNode.right, node.deep + 1);
                queue.add(rightNode);
            }

        }

        reverse(result);

        return result;
    }
}

class NodeData {
    TreeNode treeNode;
    int deep;

    public NodeData(TreeNode treeNode, int deep) {
        this.treeNode = treeNode;
        this.deep = deep;
    }
}