new soln

Author: shreymehul

1448.GoodNodes.cs

@@ -0,0 +1,47 @@
+// 1448. Count Good Nodes in Binary Tree
+// Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.
+// Return the number of good nodes in the binary tree.
+// Example 1:
+// Input: root = [3,1,4,3,null,1,5]
+// Output: 4
+// Explanation: Nodes in blue are good.
+// Root Node (3) is always a good node.
+// Node 4 -> (3,4) is the maximum value in the path starting from the root.
+// Node 5 -> (3,4,5) is the maximum value in the path
+// Node 3 -> (3,1,3) is the maximum value in the path.
+// Example 2:
+// Input: root = [3,3,null,4,2]
+// Output: 3
+// Explanation: Node 2 -> (3, 3, 2) is not good, because "3" is higher than it.
+// Example 3:
+// Input: root = [1]
+// Output: 1
+// Explanation: Root is considered as good.
+
+/**
+ * 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 int GoodNodes(TreeNode root) {
+        return 1 + Traverse(root.left,root.val) +Traverse(root.right,root.val);
+    }
+    
+    public int Traverse(TreeNode root, int max){
+        if(root == null)
+            return 0;
+        if(max > root.val){
+            return Traverse(root.left,max) +Traverse(root.right,max);
+        }
+        return 1 + Traverse(root.left,root.val) +Traverse(root.right,root.val);
+    }
+}

230.KthSmallest.cs

@@ -0,0 +1,39 @@
+// 230. Kth Smallest Element in a BST
+// Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.
+// Example 1:
+// Input: root = [3,1,4,null,2], k = 1
+// Output: 1
+// Example 2:
+// Input: root = [5,3,6,2,4,null,null,1], k = 3
+// Output: 3
+/**
+ * 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 {
+    Stack<int> st;
+    public int KthSmallest(TreeNode root, int k) {
+        st = new Stack<int>();
+        findsmallest(root,k);
+        return st.Pop();
+    }
+    public void findsmallest(TreeNode root, int k){
+        if(root == null)
+            return;
+        if(st.Count < k)
+            findsmallest(root.left,k);
+        if(st.Count < k)
+            st.Push(root.val);
+        if(st.Count < k)
+            findsmallest(root.right,k);
+    }
+}

671.FindSecondMinimumValue.cs

@@ -0,0 +1,44 @@
+// 671. Second Minimum Node In a Binary Tree
+// Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value among its two sub-nodes. More formally, the property root.val = min(root.left.val, root.right.val) always holds.
+// Given such a binary tree, you need to output the second minimum value in the set made of all the nodes' value in the whole tree.
+// If no such second minimum value exists, output -1 instead.
+// Example 1:
+// Input: root = [2,2,5,null,null,5,7]
+// Output: 5
+// Explanation: The smallest value is 2, the second smallest value is 5.
+// Example 2:
+// Input: root = [2,2,2]
+// Output: -1
+// Explanation: The smallest value is 2, but there isn't any second smallest value.
+
+/**
+ * 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 {
+    HashSet<int> hset;
+    public int FindSecondMinimumValue(TreeNode root) {
+        hset = new HashSet<int>();
+        FindMin(root);
+        if(hset.Count < 2)
+            return -1;
+        var l = hset.OrderBy(x=>x).ToList();
+        return l[1];
+    }
+    public void FindMin(TreeNode root){
+        if(root == null)
+            return;
+        hset.Add(root.val);
+        FindMin(root.left);
+        FindMin(root.right);
+    }
+}