12.力扣-树-二叉树最大宽度

力扣-树-二叉树最大宽度

二叉树最大宽度（LeetCode 662）

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

• 解题思路：这道题解题的关键就是对每层的位置进行标记，从0开始计，若一个点的位置为pos，那其左节点的位置是pos2，其右结点的位置是pos2+1
  1.宽度优先搜索（使用队列）

• 记录深度和位置，记一个新的类，以深度的值来标记不同层，以保存最大宽度

class Solution {
    public int widthOfBinaryTree(TreeNode root) {
        Queue<AnnotatedNode> queue = new LinkedList();
        queue.add(new AnnotatedNode(root, 0, 0));
        int curDepth = 0, left = 0, ans = 0;
        while (!queue.isEmpty()) {
            AnnotatedNode a = queue.poll();
            if (a.node != null) {
                queue.add(new AnnotatedNode(a.node.left, a.depth + 1, a.pos * 2));
                queue.add(new AnnotatedNode(a.node.right, a.depth + 1, a.pos * 2 + 1));
                if (curDepth != a.depth) {
                    curDepth = a.depth;
                    //标记这层的第一个不为空的点
                    left = a.pos;
                }
                ans = Math.max(ans, a.pos - left + 1);
            }
        }
        return ans;
    }
}

class AnnotatedNode {
    TreeNode node;
    int depth, pos;
    AnnotatedNode(TreeNode n, int d, int p) {
        node = n;
        depth = d;
        pos = p;
    }
}

• 每层以一个list来保存，即可以省去深度

class Solution {
    public int widthOfBinaryTree(TreeNode root) {
        Map<TreeNode,Integer> map=new HashMap<>();
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        map.put(root,0);
        int max_len=1;
        while (!queue.isEmpty()){
            int num=queue.size();
            List<Integer> lst=new ArrayList<>();
            for (int i = 0; i < num; i++) {
                TreeNode node=queue.poll();
                int pos=map.get(node);
                if(node.left!=null){
                    queue.add(node.left);
                    map.put(node.left,pos*2);
                    lst.add(pos*2);
                }
                if(node.right!=null){
                    queue.add(node.right);
                    map.put(node.right,pos*2+1);
                    lst.add(pos*2+1);
                }
            }
            if(lst.size()>=1){
                int len=lst.get((lst.size()-1))-lst.get(0)+1;
                max_len=Math.max(len,max_len);
            }
        }
        return max_len;
    }
}

2.深度优先搜索（dfs）
按照深度优先的顺序，我们记录每个节点的 position 。对于每一个深度，第一个到达的位置会被记录在 left[depth] 中。然后对于每一个节点，它对应这一层的可能宽度是 pos - left[depth] + 1 。我们将每一层这些可能的宽度去一个最大值就是答案。

class Solution {
    int ans;
    //left用来记录每个深度最左侧的pos
    Map<Integer, Integer> left;
    public int widthOfBinaryTree(TreeNode root) {
        ans = 0;
        left = new HashMap();
        dfs(root, 0, 0);
        return ans;
    }
    public void dfs(TreeNode root, int depth, int pos) {
        if (root == null) return;
        //如果depth存在，则返回depth对应的pos，如果depth不存在，则put(depth,pos)
        left.computeIfAbsent(depth, x-> pos);
        ans = Math.max(ans, pos - left.get(depth) + 1);
        dfs(root.left, depth + 1, 2 * pos);
        dfs(root.right, depth + 1, 2 * pos + 1);
    }
}