Added tasks 103-117

Author: javadev

LeetCodeNet/G0101_0200/S0103_binary_tree_zigzag_level_order_traversal/readme.md

@@ -0,0 +1,92 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 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`
+
+## Solution
+
+```csharp
+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/S0106_construct_binary_tree_from_inorder_and_postorder_traversal/readme.md

@@ -0,0 +1,70 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 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.
+
+## Solution
+
+```csharp
+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/S0108_convert_sorted_array_to_binary_search_tree/readme.md

@@ -0,0 +1,72 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 108\. Convert Sorted Array to Binary Search Tree
+
+Easy
+
+Given an integer array `nums` where the elements are sorted in **ascending order**, convert _it to a **height-balanced** binary search tree_.
+
+A **height-balanced** binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than one.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg)
+
+**Input:** nums = [-10,-3,0,5,9]
+
+**Output:** [0,-3,9,-10,null,5]
+
+**Explanation:** [0,-10,5,null,-3,null,9] is also accepted: ![](https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg) 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/btree.jpg)
+
+**Input:** nums = [1,3]
+
+**Output:** [3,1]
+
+**Explanation:** [1,3] and [3,1] are both a height-balanced BSTs. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` is sorted in a **strictly increasing** order.
+
+## Solution
+
+```csharp
+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;
+    }
+}
+```

LeetCodeNet/G0101_0200/S0112_path_sum/readme.md

@@ -0,0 +1,69 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 112\. Path Sum
+
+Easy
+
+Given the `root` of a binary tree and an integer `targetSum`, return `true` if the tree has a **root-to-leaf** path such that adding up all the values along the path equals `targetSum`.
+
+A **leaf** is a node with no children.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg)
+
+**Input:** root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg)
+
+**Input:** root = [1,2,3], targetSum = 5
+
+**Output:** false 
+
+**Example 3:**
+
+**Input:** root = [1,2], targetSum = 0
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 5000]`.
+*   `-1000 <= Node.val <= 1000`
+*   `-1000 <= targetSum <= 1000`
+
+## Solution
+
+```csharp
+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 bool HasPathSum(TreeNode root, int sum) {
+        if (root == null) {
+            return false;
+        }
+        if (sum == root.val && root.left == null && root.right == null) {
+            return true;
+        }
+        return HasPathSum(root.left, (int)(sum - root.val)) || HasPathSum(root.right, (int)(sum - root.val));
+    }
+}
+```

LeetCodeNet/G0101_0200/S0117_populating_next_right_pointers_in_each_node_ii/readme.md

@@ -0,0 +1,64 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 117\. Populating Next Right Pointers in Each Node II
+
+Medium
+
+Given a binary tree
+
+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`.
+
+Initially, all next pointers are set to `NULL`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/02/15/117_sample.png)
+
+**Input:** root = [1,2,3,4,5,null,7]
+
+**Output:** [1,#,2,3,#,4,5,7,#]
+
+**Explanation:** Given the above 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. 
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 6000]`.
+*   `-100 <= Node.val <= 100`
+
+**Follow-up:**
+
+*   You may only use constant extra space.
+*   The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.
+
+## Solution
+
+```csharp
+public class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() { }
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+}
+```