Tree Medium Level

Nivetharavi

1 min read

·

Sep 6, 2026

--

1

Listen

Share

Maximum Width of Binary Tree:
https://leetcode.com/problems/maximum-width-of-binary-tree/description/

Get Nivetharavi’s stories in your inbox
Join Medium for free to get updates from this writer.
Subscribe
Subscribe
Remember me for faster sign in
/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public int widthOfBinaryTree(TreeNode root) {
        return bfs(root);
    }

    class Pair{
        TreeNode node;
        int index;
        Pair(TreeNode node, int index) {
            this.node = node;
            this.index = index;
        }
    }

    public int bfs(TreeNode node){
        Queue<Pair> queue = new ArrayDeque<>();
        Pair rootPair = new Pair(node, 0);
        int max = Integer.MIN_VALUE;
        queue.add(rootPair);

        int leftMost = 0;
        int rightMost = 0; 

        while(queue.size()>0){
            int size = queue.size();

            for(int i=0;i<size;i++){
                Pair p = queue.remove();

                // Adding Index to Left Child
                if(p.node.left != null){
                    Pair leftPair = new Pair(p.node.left, 2*p.index+1);
                    queue.add(leftPair);
                }

                // Adding Index to Right Child
                if(p.node.right != null){
                    Pair rightPair = new Pair(p.node.right, 2*p.index+2);
                    queue.add(rightPair);
                }

                // Finding the Left Most
                if(i==0){
                    leftMost = p.index;
                    //System.out.println(leftMost);
                }

                // Finding the Right Mode
                if(i==size-1){
                    rightMost = p.index;
                    //System.out.println(rightMost);
                }
            }

            //Finding the maximum
            max = Math.max(max, rightMost-leftMost+1);
            //System.out.println(max);
        }
        return max;
    }
}