solve problem Minimum Absolute Difference In Bst

Author: P-ppc

README.md

@@ -70,6 +70,7 @@ All solutions will be accepted!
 |575|[Distribute Candies](https://leetcode-cn.com/problems/distribute-candies/description/)|[java/py/js](./algorithms/DistributeCandies)|Easy|
 |21|[Merge Two Sorted Lists](https://leetcode-cn.com/problems/merge-two-sorted-lists/description/)|[java/py/js](./algorithms/MergeTwoSortedLists)|Easy|
 |88|[Merge Sorted Array](https://leetcode-cn.com/problems/merge-sorted-array/description/)|[java/py/js](./algorithms/MergeSortedArray)|Easy|
+|530|[Minimum Absolute Difference In Bst](https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/description/)|[java/py/js](./algorithms/MinimumAbsoluteDifferenceInBst)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/MinimumAbsoluteDifferenceInBst/README.md

@@ -0,0 +1,2 @@
+# Minimum Absolute Difference In Bst
+This problem is easy to solve by inorder traversal

algorithms/MinimumAbsoluteDifferenceInBst/Solution.java

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int getMinimumDifference(TreeNode root) {
+        List<TreeNode> stack = new ArrayList<TreeNode>();
+        List<Integer> values = new ArrayList<Integer>();
+        Map<TreeNode, Boolean> traveredMap = new HashMap<TreeNode, Boolean>();
+        int minDiff = Integer.MAX_VALUE;
+        
+        stack.add(root);
+        while (stack.size() > 0) {
+            int lastIndex = stack.size() - 1;
+            TreeNode node = stack.get(lastIndex);
+            if (node.left != null && traveredMap.get(node) == null) {
+                traveredMap.put(node, true);
+                stack.add(node.left);
+            } else {
+                stack.remove(lastIndex);
+                values.add(node.val);
+                if (node.right != null) {
+                    stack.add(node.right);
+                }
+            }
+        }
+        for (int i = 1; i < values.size(); i++) {
+            minDiff = Math.min(minDiff, values.get(i) - values.get(i - 1));
+        }
+        return minDiff;
+    }
+}

algorithms/MinimumAbsoluteDifferenceInBst/solution.js

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var getMinimumDifference = function(root) {
+    let stack = [root],
+        values = [],
+        minDiff = null
+    
+    while (stack.length > 0) {
+        let node = stack[stack.length - 1]
+        if (node.left && node.travered === undefined) {
+            node.travered = true
+            stack.push(node.left)
+        } else {
+            stack.pop()
+            values.push(node.val)
+            if (node.right) stack.push(node.right)
+        }
+    }
+
+    for (let i = 1; i < values.length; i++) {
+        if (minDiff == null) minDiff = values[i] - values[i - 1]
+        else minDiff = Math.min(minDiff, values[i] - values[i - 1])
+    }
+    return minDiff
+};

algorithms/MinimumAbsoluteDifferenceInBst/solution.py

@@ -0,0 +1,34 @@
+# 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 getMinimumDifference(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        # inorder traversal
+        stack = [root]
+        travered_map = {}
+        values = []
+        while len(stack) > 0:
+            node = stack[-1]
+            if node.left and travered_map.get(node) == None:
+                travered_map[node] = True
+                stack.append(node.left)
+            else:
+                stack.pop()
+                values.append(node.val)
+                if node.right:
+                    stack.append(node.right)
+        min_diff = None
+        for i in range(1, len(values)):
+            if min_diff == None:
+                min_diff = values[i] - values[i - 1]
+            else:
+                min_diff = min(min_diff, values[i] - values[i - 1])
+        return min_diff