Added tasks 103-117

Author: ThanhNIT

LeetCodeNet.Tests/G0101_0200/S0103_binary_tree_zigzag_level_order_traversal/SolutionTest.cs

@@ -0,0 +1,34 @@
+namespace LeetCodeNet.G0101_0200.S0103_binary_tree_zigzag_level_order_traversal {
+
+using LeetCodeNet.Com_github_leetcode;
+using Xunit;
+using System.Collections.Generic;
+
+public class SolutionTest {
+    [Fact]
+    public void ZigzagLevelOrder() {
+        var root = TreeNode.Create(new List<int?> {3, 9, 20, null, null, 15, 7});
+        var expected = new List<IList<int>> {
+            new List<int> {3},
+            new List<int> {20, 9},
+            new List<int> {15, 7}
+        };
+        Assert.Equal(expected, new Solution().ZigzagLevelOrder(root));
+    }
+
+    [Fact]
+    public void ZigzagLevelOrder2() {
+        var root = TreeNode.Create(new List<int?> {1});
+        var expected = new List<IList<int>> {
+            new List<int> {1}
+        };
+        Assert.Equal(expected, new Solution().ZigzagLevelOrder(root));
+    }
+
+    [Fact]
+    public void ZigzagLevelOrder3() {
+        var expected = new List<IList<int>>();
+        Assert.Equal(expected, new Solution().ZigzagLevelOrder(null));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0106_construct_binary_tree_from_inorder_and_postorder_traversal/SolutionTest.cs

@@ -0,0 +1,23 @@
+namespace LeetCodeNet.G0101_0200.S0106_construct_binary_tree_from_inorder_and_postorder_traversal {
+
+    using Xunit;
+    using LeetCodeNet.Com_github_leetcode;
+    
+    public class SolutionTest {
+        [Fact]
+        public void ConstructBinaryTree() {
+            int[] inorder = {9, 3, 15, 20, 7};
+            int[] postorder = {9, 15, 7, 20, 3};
+            TreeNode actual = new Solution().BuildTree(inorder, postorder);
+            Assert.Equal("3,9,20,15,7", actual.ToString());
+        }
+
+        [Fact]
+        public void ConstructBinaryTree2() {
+            int[] inorder = {-1};
+            int[] postorder = {-1};
+            TreeNode actual = new Solution().BuildTree(inorder, postorder);
+            Assert.Equal("-1", actual.ToString());
+        }
+    }
+} 

LeetCodeNet.Tests/G0101_0200/S0108_convert_sorted_array_to_binary_search_tree/SolutionTest.cs

@@ -0,0 +1,19 @@
+namespace LeetCodeNet.G0101_0200.S0108_convert_sorted_array_to_binary_search_tree {
+
+    using Xunit;
+    using LeetCodeNet.Com_github_leetcode;
+    
+    public class SolutionTest {
+        [Fact]
+        public void SortedArrayToBST() {
+            var actual = new Solution().SortedArrayToBST(new int[] {-10, -3, 0, 5, 9});
+            Assert.Equal("0,-10,null,-3,5,null,9", actual.ToString());
+        }
+
+        [Fact]
+        public void SortedArrayToBST2() {
+            var actual = new Solution().SortedArrayToBST(new int[] {1, 3});
+            Assert.Equal("1,null,3", actual.ToString());
+        }
+    }
+} 

LeetCodeNet.Tests/G0101_0200/S0112_path_sum/SolutionTest.cs

@@ -0,0 +1,25 @@
+namespace LeetCodeNet.G0101_0200.S0112_path_sum {
+
+    using Xunit;
+    using System.Collections.Generic;
+    using LeetCodeNet.Com_github_leetcode;
+
+    public class SolutionTest {
+        [Fact]
+        public void HasPathSum() {
+            var root = TreeNode.Create(new List<int?> {5, 4, 8, 11, null, 13, 4, 7, 2, null, null, null, 1});
+            Assert.True(new Solution().HasPathSum(root, 22));
+        }
+
+        [Fact]
+        public void HasPathSum2() {
+            var root = TreeNode.Create(new List<int?> {1, 2, 3});
+            Assert.False(new Solution().HasPathSum(root, 22));
+        }
+
+        [Fact]
+        public void HasPathSum3() {
+            Assert.False(new Solution().HasPathSum(null, 0));
+        }
+    }
+} 

LeetCodeNet.Tests/G0101_0200/S0117_populating_next_right_pointers_in_each_node_ii/SolutionTest.cs

@@ -0,0 +1,49 @@
+namespace LeetCodeNet.G0101_0200.S0117_populating_next_right_pointers_in_each_node_ii {
+
+    using Xunit;
+
+    public class SolutionTest {
+        [Fact]
+        public void Connect() {
+            Assert.Null(new Solution().Connect(null));
+        }
+
+        [Fact]
+        public void Connect2() {
+            var node = new Node(
+                1,
+                new Node(2, new Node(4), new Node(5), null),
+                new Node(3, null, new Node(7), null),
+                null);
+
+            var node7 = new Node(7);
+            var node3 = new Node(3, null, node7, null);
+            var node5 = new Node(5, null, null, node7);
+            var node4 = new Node(4, null, null, node5);
+            var node2 = new Node(2, node4, node5, node3);
+            var node1 = new Node(1, node2, node3, null);
+
+            Assert.Equal(node1.ToString(), new Solution().Connect(node).ToString());
+        }
+
+        [Fact]
+        public void Connect3() {
+            var node = new Node(
+                1,
+                new Node(2, new Node(4, new Node(7), null, null), new Node(5), null),
+                new Node(3, null, new Node(6, null, new Node(8), null), null),
+                null);
+
+            var node8 = new Node(8, null, null, null);
+            var node7 = new Node(7, null, null, node8);
+            var node6 = new Node(6, null, node8, null);
+            var node3 = new Node(3, null, node6, null);
+            var node5 = new Node(5, null, null, node6);
+            var node4 = new Node(4, node7, null, node5);
+            var node2 = new Node(2, node4, node5, node3);
+            var node1 = new Node(1, node2, node3, null);
+
+            Assert.Equal(node1.ToString(), new Solution().Connect(node).ToString());
+        }
+    }
+} 

LeetCodeNet/G0101_0200/S0103_binary_tree_zigzag_level_order_traversal/Solution.cs

@@ -0,0 +1,61 @@
+namespace LeetCodeNet.G0101_0200.S0103_binary_tree_zigzag_level_order_traversal {
+
+// #Medium #Top_Interview_Questions #Breadth_First_Search #Tree #Binary_Tree
+// #Data_Structure_II_Day_15_Tree #Udemy_Tree_Stack_Queue #Top_Interview_150_Binary_Tree_BFS
+// #2025_07_09_Time_0_ms_(100.00%)_Space_46.86_MB_(87.33%)
+
+using System.Collections.Generic;
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * 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 {
+    public IList<IList<int>> ZigzagLevelOrder(TreeNode root) {
+        var queue = new Queue<TreeNode>();
+        var results = new List<IList<int>>();
+        if (root == null) {
+            return results;
+        }
+        var level = new List<int>();
+        queue.Enqueue(root);
+        queue.Enqueue(null);
+        var d = false;
+        while (queue.Count > 0) {
+            var c = queue.Dequeue();
+            if (c == null) {
+                if (d) {
+                    level.Reverse();
+                }
+                results.Add(level);
+                if (queue.Count == 0) {
+                    break;
+                } else {
+                    queue.Enqueue(null);
+                    level = new List<int>();
+                    d = !d;
+                }
+            } else {
+                level.Add((int)c.val);
+                if (c.left != null) {
+                    queue.Enqueue(c.left);
+                }
+                if (c.right != null) {
+                    queue.Enqueue(c.right);
+                }
+            }
+        }
+        return results;
+    }
+}
+} 

LeetCodeNet/G0101_0200/S0103_binary_tree_zigzag_level_order_traversal/readme.md

@@ -0,0 +1,30 @@
+103\. Binary Tree Zigzag Level Order Traversal
+
+Medium
+
+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:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [[3],[20,9],[15,7]] 
+
+**Example 2:**
+
+**Input:** root = [1]
+
+**Output:** [[1]] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 2000]`.
+*   `-100 <= Node.val <= 100`

LeetCodeNet/G0101_0200/S0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.cs

@@ -0,0 +1,39 @@
+namespace LeetCodeNet.G0101_0200.S0106_construct_binary_tree_from_inorder_and_postorder_traversal {
+
+// #Medium #Array #Hash_Table #Tree #Binary_Tree #Divide_and_Conquer
+// #Top_Interview_150_Binary_Tree_General #2025_07_09_Time_0_ms_(100.00%)_Space_44.29_MB_(90.60%)
+
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * 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 {
+    public TreeNode BuildTree(int[] inorder, int[] postorder) {
+        int inIndex = inorder.Length - 1;
+        int postIndex = postorder.Length - 1;
+        return Helper(inorder, postorder, ref inIndex, ref postIndex, int.MaxValue);
+    }
+
+    private TreeNode Helper(int[] inorder, int[] postorder, ref int inIndex, ref int postIndex, int target) {
+        if (inIndex < 0 || inorder[inIndex] == target) {
+            return null;
+        }
+        TreeNode root = new TreeNode(postorder[postIndex--]);
+        root.right = Helper(inorder, postorder, ref inIndex, ref postIndex, (int)root.val);
+        inIndex--;
+        root.left = Helper(inorder, postorder, ref inIndex, ref postIndex, target);
+        return root;
+    }
+}
+} 

LeetCodeNet/G0101_0200/S0106_construct_binary_tree_from_inorder_and_postorder_traversal/readme.md

@@ -0,0 +1,29 @@
+106\. Construct Binary Tree from Inorder and Postorder Traversal
+
+Medium
+
+Given two integer arrays `inorder` and `postorder` where `inorder` is the inorder traversal of a binary tree and `postorder` is the postorder traversal of the same tree, construct and return _the binary tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg)
+
+**Input:** inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
+
+**Output:** [3,9,20,null,null,15,7] 
+
+**Example 2:**
+
+**Input:** inorder = [-1], postorder = [-1]
+
+**Output:** [-1] 
+
+**Constraints:**
+
+*   `1 <= inorder.length <= 3000`
+*   `postorder.length == inorder.length`
+*   `-3000 <= inorder[i], postorder[i] <= 3000`
+*   `inorder` and `postorder` consist of **unique** values.
+*   Each value of `postorder` also appears in `inorder`.
+*   `inorder` is **guaranteed** to be the inorder traversal of the tree.
+*   `postorder` is **guaranteed** to be the postorder traversal of the tree.

LeetCodeNet/G0101_0200/S0108_convert_sorted_array_to_binary_search_tree/Solution.cs

@@ -0,0 +1,38 @@
+namespace LeetCodeNet.G0101_0200.S0108_convert_sorted_array_to_binary_search_tree {
+
+// #Easy #Top_Interview_Questions #Array #Tree #Binary_Tree #Binary_Search_Tree #Divide_and_Conquer
+// #Data_Structure_II_Day_15_Tree #Level_2_Day_9_Binary_Search_Tree #Udemy_Tree_Stack_Queue
+// #Top_Interview_150_Divide_and_Conquer #2025_07_09_Time_0_ms_(100.00%)_Space_45.24_MB_(54.95%)
+
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * 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 {
+    public TreeNode SortedArrayToBST(int[] nums) {
+        return MakeTree(nums, 0, nums.Length - 1);
+    }
+
+    private TreeNode MakeTree(int[] nums, int left, int right) {
+        if (left > right) {
+            return null;
+        }
+        int mid = (left + right) / 2;
+        TreeNode midNode = new TreeNode(nums[mid]);
+        midNode.left = MakeTree(nums, left, mid - 1);
+        midNode.right = MakeTree(nums, mid + 1, right);
+        return midNode;
+    }
+}
+}