1. 题目

原题链接

给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节
点为空。
每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。
示例 1:

输入:
1
/
3 2
/ \ \
5 3 9
输出: 4
解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。

示例 2:

输入:
1
/
3
/ \
5 3
输出: 2
解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。

2. 题解

2.1 解法1: 层序遍历

主要思路: 由于形状与满二叉树相同, 遍历过程中, 给每个节点进行编号并记录, 若当前结点为 i, 则左儿子为 2i, 右儿子为 2i+1, 每次遍历一层, 遍历3完一层后, 记录的最后一个值和最前一个值, 分别为该层的最右节点和最左节点, 两者相减即为该层宽度, 然后滚动比较即可得到最大宽度

    class Solution {
        public int widthOfBinaryTree(TreeNode root) {
            if (root == null) {
                return 0;
            }
            Queue<TreeNode> treeQue = new LinkedList<>();
            LinkedList<Integer> indexQue = new LinkedList<>();
            treeQue.offer(root);
            indexQue.addLast(1);
            int ans = 1;
            while (!treeQue.isEmpty()) {
                int size = treeQue.size();
                for (int i = 0; i < size; i++) {
                    TreeNode temp = treeQue.poll();
                    int index = indexQue.removeFirst();
                    if (temp.left != null) {
                        treeQue.offer(temp.left);
                        indexQue.addLast(2 * index);
                    }
                    if (temp.right != null) {
                        treeQue.offer(temp.right);
                        indexQue.addLast(2 * index + 1);
                    }
                }
                // 每遍历完一层, 计算该层宽度, 同时当该层节点数大于 1 时才计算
                if (indexQue.size() > 1) {
                    ans = Math.max(ans, indexQue.peekLast() - indexQue.peekFirst() + 1);
                }
            }
            return ans;
        }
    }

参考: 层次遍历实现

2.2 解法2: DFS

设置全局变量 ans, map用于保存每层的最左节点的位置值, 最早遍历到的即为最左, 这里可以使用 map 的 putIfAbsent 函数,
该函数若 key 不存在, 则放入, 若存在, 则不进行任何操作

递归函数

参数: 当前遍历结点 root, 当前深度 depth, 当前结点索引位置 index
作用: 计算最大宽度
调用过程: 更新 map, 滚动计算最大宽度

    class Solution {
        int ans;
        Map<Integer, Integer> map;

        public int widthOfBinaryTree(TreeNode root) {
            map = new HashMap<>();
            ans = 0;
            dfs(root, 1, 1);
            return ans;
        }

        public void dfs(TreeNode root, int depth, int index) {
            if (root == null) {
                return;
            }
            map.putIfAbsent(depth, index);
            ans = Math.max(ans, index - map.get(depth) + 1);
            dfs(root.left, depth + 1, 2 * index);
            dfs(root.right, depth + 1, 2 * index + 1);
        }


    }

参考: 官方题解