package com.算法专练.力扣.二叉树最大宽度;
import javafx.util.Pair;
import sun.reflect.generics.tree.Tree;
import java.awt.*;
import java.util.*;
import java.util.List;
/**
* @author xnl
* @Description:
* @date: 2022/8/27 22:45
*/
public class Solution {
public static void main(String[] args) {
Solution solution = new Solution();
TreeNode node = new TreeNode(1, new TreeNode(3, new TreeNode(5), new TreeNode(3)), new TreeNode(2, null, new TreeNode(9)));
System.out.println(solution.widthOfBinaryTree(node));
}
/**
* 广度优先算法,需要注意的是pair对象。就和map差不多
* @param root
* @return
*/
public int widthOfBinaryTree(TreeNode root) {
if (root == null){
return 0;
}
int res = 1;
List<Pair<TreeNode, Integer>> list = new ArrayList<Pair<TreeNode, Integer>>();
list.add(new Pair<>(root, 1));
while (!list.isEmpty()){
List<Pair<TreeNode, Integer>> temp = new ArrayList<>();
for (Pair<TreeNode, Integer> pair : list){
TreeNode node = pair.getKey();
Integer index = pair.getValue();
if (node.left != null){
temp.add(new Pair<>(node.left, index * 2));
}
if (node.right != null){
temp.add(new Pair<>(node.right, index * 2 + 1));
}
}
res = Math.max(res, list.get(list.size() - 1).getValue() - list.get(0).getValue() + 1);
list = temp;
}
return res;
}
/**
* 深度优先算法
* 与广度优先 遍历类似,都是记录节点
* 判断开始节点的位置,然后计算使用到了多少个节点
* 父节点的左子节点等于 node * 2, 右节点等于 node * 2 + 1
* @param root
* @return
*/
int result = 0;
Map<Integer, Integer> map = new HashMap<>();
public int widthOfBinaryTree2(TreeNode root) {
dfs(root, 1, 0);
return result;
}
private void dfs(TreeNode node, int nodeIndex, int level){
if (node == null){
return;
}
map.putIfAbsent(level, nodeIndex);
result = Math.max(result, nodeIndex - map.get(level) + 1);
dfs(node.left, nodeIndex * 2, level + 1);
dfs(node.right, nodeIndex * 2 + 1, level + 1);
}
}
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
力扣:662. 二叉树最大宽度
于 2022-08-27 23:33:06 首次发布