cleanup

Author: shreymehul

102.LevelOrder.cs

@@ -46,7 +46,7 @@ public IList<IList<int>> LevelOrder(TreeNode root) {
                 level.Add(currNode.val);
                 if (currNode.right != null)
                     queue.Enqueue(currNode.right);
-                    if (currNode.left != null)
+                if (currNode.left != null)
                     queue.Enqueue(currNode.left);
             }
             res.Add(level);

103.ZigzagLevelOrder.cs

@@ -1,5 +1,6 @@
 // 103. Binary Tree Zigzag Level Order Traversal
-// Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right, then right to left for the next level and alternate between).
+// Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right,
+// then right to left for the next level and alternate between).
 
  // Example 1:
 // Input: root = [3,9,20,null,null,15,7]

116.Connect.cs

@@ -1,21 +1,23 @@
 // 116. Populating Next Right Pointers in Each Node
 
-// You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:
+// You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. 
+// The binary tree has the following definition:
 
 // struct Node {
 //   int val;
 //   Node *left;
 //   Node *right;
 //   Node *next;
 // }
-// Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
+// Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be
+// set to NULL.
 
 // Initially, all next pointers are set to NULL.
 
 // Example 1:
 // Input: root = [1,2,3,4,5,6,7]
 // Output: [1,#,2,3,#,4,5,6,7,#]
-// Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+// Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to 
 // Example 2:
 // Input: root = []
 // Output: []

122.MaxProfit.cs

@@ -3,7 +3,7 @@
 // You are given an integer array prices where prices[i] is the price of a given stock on the ith day.
 
 // On each day, you may decide to buy and/or sell the stock. You can only hold at most one share of the stock at any time. 
-//However, you can buy it then immediately sell it on the same day.
+// However, you can buy it then immediately sell it on the same day.
 
 // Find and return the maximum profit you can achieve.
 

124.MaxPathSum.cs

@@ -1,5 +1,6 @@
 // 124. Binary Tree Maximum Path Sum
-// A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.
+// A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them.
+// A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.
 // The path sum of a path is the sum of the node's values in the path.
 // Given the root of a binary tree, return the maximum path sum of any non-empty path.
 // Example 1:

152.MaxProduct.cs

@@ -1,7 +1,7 @@
 // 152. Maximum Product Subarray
 
 // Given an integer array nums, find a subarray
-//  that has the largest product, and return the product.
+// that has the largest product, and return the product.
 
 // The test cases are generated so that the answer will fit in a 32-bit integer.
 

173.BSTIterator.cs

@@ -1,7 +1,8 @@
 // 173. Binary Search Tree Iterator
 // Implement the BSTIterator class that represents an iterator over the in-order traversal of a binary search tree (BST):
 
-// BSTIterator(TreeNode root) Initializes an object of the BSTIterator class. The root of the BST is given as part of the constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.
+// BSTIterator(TreeNode root) Initializes an object of the BSTIterator class. The root of the BST is given as part of the
+// constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.
 // boolean hasNext() Returns true if there exists a number in the traversal to the right of the pointer, otherwise returns false.
 // int next() Moves the pointer to the right, then returns the number at the pointer.
 // Notice that by initializing the pointer to a non-existent smallest number, the first call to next() will return the smallest element in the BST.

198.Rob.cs

@@ -5,7 +5,7 @@
 // it will automatically contact the police if two adjacent houses were broken into on the same night.
 
 // Given an integer array nums representing the amount of money of each house, return the maximum amount of money you
-//   can rob tonight without alerting the police.
+// can rob tonight without alerting the police.
 
 // Example 1:
 

203.RemoveElements.cs

@@ -1,7 +1,7 @@
 //203. Remove Linked List Elements
-//Given the head of a linked list and an integer val, remove all the nodes of the linked list that has Node.val == val, and
+// Given the head of a linked list and an integer val, remove all the nodes of the linked list that has Node.val == val, and
 // return the new head.
-//definition for singly-linked list.
+// definition for singly-linked list.
 public class listnode
 {
     public int val;

380. RandomizedSet.cs renamed to 380.RandomizedSet.cs

@@ -53,4 +53,43 @@ public int LargestRectangleArea(int[] heights) {
         return maxarea;
 
     }
+}
+
+
+public class Solution {
+    public int LargestRectangleArea(int[] heights)
+    {
+        // Edge case: if heights array is empty or null
+        if (heights == null || heights.Length == 0)
+            return 0;
+
+        // Stack to store indices of histogram bars
+        Stack<int> stack = new Stack<int>();
+        int maxArea = 0;
+
+        // Traverse all bars and an extra iteration to process remaining stack
+        for (int i = 0; i <= heights.Length; i++)
+        {
+            // Handle the final case where we treat the "last" height as 0
+            int currentHeight = (i == heights.Length) ? 0 : heights[i];
+
+            // Maintain a non-decreasing height stack; calculate area for taller bars
+            while (stack.Count > 0 && currentHeight < heights[stack.Peek()])
+            {
+                // Pop the top element which represents the height of a rectangle
+                int height = heights[stack.Pop()];
+
+                // Calculate the width of the rectangle
+                int width = stack.Count == 0 ? i : i - stack.Peek() - 1;
+
+                // Update max area if a larger rectangle is found
+                maxArea = Math.Max(maxArea, height * width);
+            }
+
+            // Push the current bar's index onto the stack
+            stack.Push(i);
+        }
+
+        return maxArea;
+    }
 }