Leetcode discuss: 1302. Deepest Leaves Sum

 Here is the link. 

C# Apply level order traversal and calculate sum of each level nodes

August 31, 2020
1302. Deepest Leaves Sum

Introduction
It is easy to apply level order traversal and also calculate sum of all nodes in the same level.
Last level is easy to determine by checking queue's size.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    /// <summary>
        /// August 31, 2020
        /// using level order traversal, and then calculate the sum of all nodes in the same level
        /// If the level is last level, then sum is the answer
        /// </summary>
        /// <param name="root"></param>
        /// <returns></returns>
        public int DeepestLeavesSum(TreeNode root)
        {
            if (root == null)
            {
                return 0; 
            }

            var queue = new Queue<TreeNode>();
            queue.Enqueue(root);
            var lastLevel = 0; 

            while (queue.Count > 0)
            {
                var levelSize = queue.Count;
                var sum = 0; 
                for (int i = 0; i < levelSize; i++)
                {
                    var node = queue.Dequeue();
                    sum += node.val;

                    if (node.left != null)
                    {
                        queue.Enqueue(node.left);
                    }

                    if (node.right != null)
                    {
                        queue.Enqueue(node.right);
                    }
                }

                if (queue.Count == 0)
                {
                    lastLevel = sum; 
                }
            }

            return lastLevel; 
        }
}