671_Second_Minimum_Node_In_a_Binary_Tree

Author: qiyuangong

README.md

@@ -165,6 +165,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 617 | [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/617_Merge_Two_Binary_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/617_Merge_Two_Binary_Trees.java) | Traverse both trees Recursion & Iterative (stack) |
 | 628 | [Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/628_Maximum_Product_of_Three_Numbers.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/628_Maximum_Product_of_Three_Numbers.java) | Actually, we should only care about min1, min2 and max1-max3, to find these five elements, we can use 1. Brute force, O(n^3) and O(1)<br>2. Sort, O(nlogn) and O(1)<br>3. Single scan with 5 elements keep, O(n) and O(1) |
 | 654 | [Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/654_Maximum_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/654_Maximum_Binary_Tree.java) | 1. Divide and conquer, recursive, O(n^2)<br>2. Monotonic stack, O(n) |
+| 671 | [Second Minimum Node In a Binary Tree](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/671_Second_Minimum_Node_In_a_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/671_Second_Minimum_Node_In_a_Binary_Tree.java) | Note that min value is root: 1. Get all values then find result, O(n) and O(n)<br>2. BFS or DFS traverse the tree, then find the reslut, O(n) and O(n)|
 | 674 | [Longest Continuous Increasing Subsequence](https://leetcode.com/problems/longest-continuous-increasing-subsequence/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/674_Longest_Continuous_Increasing_Subsequence.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/674_Longest_Continuous_Increasing_Subsequence.java) | Scan nums once, check nums[i] < nums[i+1], if not reset count, O(n) and O(1) |
 | 680 | [Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/680_Valid_Palindrome_II.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/680_Valid_Palindrome_II.java) | Recursively check s[left == end, when not equal delete left or right. |
 | 692 | [Top K Frequent Words](https://leetcode.com/problems/top-k-frequent-words/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/692_Top_K_Frequent_Words.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/692_Top_K_Frequent_Words.java) | 1. Sort based on frequency and alphabetical order, O(nlgn) and O(n)<br>2. Find top k with Heap, O(nlogk) and O(n) |

java/671_Second_Minimum_Node_In_a_Binary_Tree.java

@@ -0,0 +1,40 @@
+class Solution {
+    /*public void dfs(TreeNode root, Set<Integer> uniques) {
+        if (root != null) {
+            uniques.add(root.val);
+            dfs(root.left, uniques);
+            dfs(root.right, uniques);
+        }
+    }
+    public int findSecondMinimumValue(TreeNode root) {
+        // Brute force
+        Set<Integer> uniques = new HashSet<Integer>();
+        dfs(root, uniques);
+
+        int min1 = root.val;
+        long ans = Long.MAX_VALUE;
+        for (int v : uniques) {
+            if (min1 < v && v < ans) ans = v;
+        }
+        return ans < Long.MAX_VALUE ? (int) ans : -1;
+    }*/
+
+    public int findSecondMinimumValue(TreeNode root) {
+        if (root == null) return -1;
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        int min_val = root.val;
+        int ans = Integer.MAX_VALUE;
+        stack.push(root);
+        while (!stack.empty()) {
+            TreeNode node = stack.pop();
+            if (node == null) continue;
+            if (node.val < ans && node.val > min_val) {
+                ans = node.val;
+            } else if (node.val == min_val) {
+                stack.push(node.left);
+                stack.push(node.right);
+            }
+        }
+        return ans < Integer.MAX_VALUE ? ans : -1;
+    }
+}

python/671_Second_Minimum_Node_In_a_Binary_Tree.py

@@ -0,0 +1,45 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    # def findSecondMinimumValue(self, root):
+    #     """
+    #     :type root: TreeNode
+    #     :rtype: int
+    #     """
+    #     # Brute force
+    #     values = set()
+    #     self.dfs(root, values)
+    #     ans, min_value = float('inf'), root.val
+    #     for n in values:
+    #         if min_value < n and n < ans:
+    #             ans = n
+    #     return ans if ans < float('inf') else -1
+
+    # def dfs(self, root, values):
+    #     if not root:
+    #         return
+    #     values.add(root.val)
+    #     self.dfs(root.left, values)
+    #     self.dfs(root.right, values)
+
+    def findSecondMinimumValue(self, root):
+        if not root:
+            return -1
+        ans = float('inf')
+        min_val = root.val
+        stack = [root]
+        while stack:
+            curr = stack.pop()
+            if not curr:
+                continue
+            if min_val < curr.val < ans:
+                ans = curr.val
+            elif curr.val == min_val:
+                stack.append(curr.left)
+                stack.append(curr.right)
+        return ans if ans < float('inf') else -1