力扣：662. 二叉树最大宽度

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;
      }
  }