计算二叉树的最大宽度 Maximum Width of Binary Tree

最新推荐文章于 2022-11-02 13:22:23 发布

weixin_34192816

最新推荐文章于 2022-11-02 13:22:23 发布

阅读量677

点赞数

文章标签：数据结构与算法 c/c++ java

原文链接：https://my.oschina.net/liyurong/blog/1606474

版权

为什么80%的码农都做不了架构师？>>>

问题：

Given a binary tree, write a function to get the maximum width of the given tree. The width of a tree is the maximum width among all levels. The binary tree has the same structure as a full binary tree, but some nodes are null.

The width of one level is defined as the length between the end-nodes (the leftmost and right most non-null nodes in the level, where the null nodes between the end-nodes are also counted into the length calculation.

Example 1:

Input: 
           1
         /   \
        3     2
       / \     \  
      5   3     9 
Output: 4
Explanation: The maximum width existing in the third level with the length 4 (5,3,null,9).

Example 2:

Input: 
          1
         /  
        3    
       / \       
      5   3     
Output: 2
Explanation: The maximum width existing in the third level with the length 2 (5,3).

Example 3:

Input: 
          1
         / \
        3   2 
       /        
      5      
Output: 2
Explanation: The maximum width existing in the second level with the length 2 (3,2).

Example 4:

Input: 
          1
         / \
        3   2
       /     \  
      5       9 
     /         \
    6           7
Output: 8
Explanation:The maximum width existing in the fourth level with the length 8 (6,null,null,null,null,null,null,7).

Note: Answer will in the range of 32-bit signed integer.

解决：

① BFS。

对二叉树节点进行标号，根节点标号为1；若某节点标号为c，则其左右孩子标号分别为2c, 2c + 1

某层的宽度即为最右、最左节点标号之差+1

所以，在算法中：

1. 记录每一层的最左节点的id。

2. 在每个节点处，比较最左边节点与当前节点最大宽度的距离;

import java.util.Map.Entry;
import java.util.AbstractMap;
class Solution { //14ms
public int widthOfBinaryTree(TreeNode root) {
if (root == null) return 0;
int max = 0;//最大宽度
Queue<Map.Entry<TreeNode,Integer>> queue = new LinkedList<>();
queue.offer(new AbstractMap.SimpleEntry<TreeNode, Integer>(root,1));
while (! queue.isEmpty()){
int left = queue.peek().getValue();
int right = left;
int count = queue.size();
for (int i = 0;i < count;i ++){
TreeNode cur = queue.peek().getKey();
right = queue.poll().getValue();
if (cur.left != null) queue.offer(new AbstractMap.SimpleEntry<TreeNode, Integer>(cur.left,2 * right));
if (cur.right != null) queue.offer(new AbstractMap.SimpleEntry<TreeNode, Integer>(cur.right,2 * right + 1));
}
max = Math.max(max,right - left + 1);
}
return max;
}
}

另一种BFS方式：

class Solution { //14ms
public int widthOfBinaryTree(TreeNode root) {
if(root == null){
return 0;
}
Queue<TreeNode> queue = new LinkedList<>(); //用于树的广度优先遍历。
Queue<Integer> queuePos = new LinkedList<>(); //用于保存上面队列中树节点对应的位置标号。
queue.add(root);
queuePos.add(1);//在顶层跟结点位置为1.
int countCurrent = 1;//记录正在遍历的当前层次的剩余数量。
int countTmp = 0; //记录下一层次结点的数量。
int max = countCurrent; //记录最大的差距。（目标）（与start 和 end相关）
int start = 1;//记录某层次结点的最左边的结点。
int end = 1;//记录某层次结点的最右边的结点。
while(! queue.isEmpty()){
TreeNode current = queue.poll();
end = queuePos.poll();
if(current.left != null){
queue.add(current.left);
queuePos.add(2 * end);//分配左孩子结点的序号。
countTmp ++;//记录下层结点的数量
}
if(current.right != null){
queue.add(current.right);
queuePos.add(2 * end + 1); //分配右孩子结点的序号
countTmp ++;
}
//当前层次已遍历完毕，计算max,并且为下一层次的遍历准备。
if(-- countCurrent == 0){
// 目标比对。
if(max < end - start + 1){
max = end - start + 1;
}
countCurrent = countTmp;//设置下一层次剩余的数量
countTmp = 0;
//设置下一层结点的start.
start = queuePos.isEmpty() ? 1 : queuePos.peek();
}
}
return max;
}
}

② dfs，跟上面的思路一样，记录每层的最左节点，然后遍历计算最大宽度。

class Solution { //9ms
public int widthOfBinaryTree(TreeNode root) {
List<Integer> lefts = new ArrayList<>();//记录每行的最左节点
return dfs(root,1,0,lefts);
}
public int dfs(TreeNode root,int id,int level,List<Integer> lefts){
if (root == null) return 0;
if (level >= lefts.size()) lefts.add(id);
return Math.max(id - lefts.get(level) + 1,
Math.max(dfs(root.left,id * 2,level + 1,lefts),
dfs(root.right,id * 2 + 1,level + 1,lefts)));
}
}