2. // 初始化：当前层数，当前层节点个数，全局最大个数，Map(head,1)头节点在一层，头节点进队列。
    3. // 头节点出队列，左右孩子进队列，Map(children,2)设置层数，更新全局最大数，
    4. // 设置为二层，重置当前层节点数。周而复始。
    5. //通过层数变更来更新当前层节点数，更新最大值
    6. public static int  MaxWidth(Node head){
    7.             if( head == null){
    8.                 return 0;
    9.             }
    10.             // 当前层数
    11.             int curLevel = 1;
    12.             // 当前层节点数量
    13.             int nodes = 0;
    14.             // 全局节点最大数量
    15.             int max = Integer.MIN_VALUE;
    16.             // 放入头，设置第一层
    17.             HashMap<Node, Integer> hashMap = new HashMap<>();
    18.             hashMap.put(head, 1);
    20.             // 初始队列
    21.             Queue<Node> queue = new LinkedList<Node>();
    22.             queue.add(head);
    23.             while(!queue.isEmpty()){            
    24.                 // 取值
    25.                 Node cur = queue.poll();        
    26.                 // 取当前值层级
    27.                 int level = hashMap.get(cur);        
    28.                 // 同一层，节点个数++
    29.                 if(level == curLevel){
    30.                     nodes++;
    31.                 }else{
    32.                     // 做清算max，更新下一层，节点个数为一，因为已经是下一层节点
    33.                     max = Math.max(max, nodes);
    34.                     curLevel++;
    35.                     nodes = 1;
    36.                 }
    37.                 if(cur.left != null){
    38.                     hashMap.put(cur.left, level+1);
    39.                     queue.add(cur.left);
    40.                 }
    41.                 if(cur.right != null){
    42.                     hashMap.put(cur.right, level+1);
    43.                     queue.add(cur.right);
    44.                 }
    45.             }
    46.             // 最后再清算一次，或许最后一层节点数量最多。但因为是最后一层触发不了清算。
    47.             max = Math.max(max, nodes);
    49.             return max;
    50.         }