Create: minimum-distance-between-two-bst-nodes

Author: AkifhanIlgaz

Diff for: go/minimum-distance-between-two-bst-nodes.go

@@ -0,0 +1,43 @@
+package main
+
+import "math"
+
+func main() {
+
+}
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func minDiffInBST(root *TreeNode) int {
+	var prev *TreeNode
+	res := math.MaxInt
+
+	var dfs func(*TreeNode)
+
+	dfs = func(node *TreeNode) {
+		if node != nil {
+			dfs(node.Left)
+
+			if prev != nil {
+				res = min(res, node.Val-prev.Val)
+			}
+			prev = node
+
+			dfs(node.Right)
+		}
+	}
+
+	dfs(root)
+	return res
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

Diff for: javascript/minimum-distance-between-two-bst-nodes.js

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var minDiffInBST = function (root) {
+    let [prev, res] = [null, Number.MAX_VALUE];
+
+    function dfs(node) {
+        if (node) {
+            dfs(node.left);
+
+            if (prev) {
+                res = Math.min(res, node.val - prev.val);
+            }
+            prev = node;
+
+            dfs(node.right);
+        }
+    }
+
+    dfs(root);
+
+    return res;
+};

Diff for: rust/minimum-distance-between-two-bst-nodes.rs

@@ -0,0 +1,30 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+type OptNode = Option<Rc<RefCell<TreeNode>>>;
+
+impl Solution {
+    pub fn min_diff_in_bst(root: OptNode) -> i32 {
+        let mut min = i32::MAX;
+        let mut prev = None;
+
+        Self::dfs(root, &mut prev, &mut min);
+        min
+    }
+
+    fn dfs(root: Option<Rc<RefCell<TreeNode>>>, prev: &mut Option<i32>, min: &mut i32) {
+        if let Some(node) = root {
+            let node = node.borrow();
+
+            Self::dfs(node.left.clone(), prev, min);
+
+            if let Some(prev) = prev {
+                *min = (*min).min(node.val - *prev)
+            }
+            *prev = Some(node.val);
+
+            Self::dfs(node.right.clone(), prev, min);
+        }
+    }
+}
+

Diff for: typescript/minimum-distance-between-two-bst-nodes.ts

@@ -0,0 +1,33 @@
+class TreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
+export {};
+
+function minDiffInBST(root: TreeNode | null): number {
+    let prev: TreeNode | null = null;
+    let res = Number.MAX_VALUE;
+
+    function dfs(node: TreeNode | null): void {
+        if (node) {
+            dfs(node.left);
+
+            if (prev) {
+                res = Math.min(res, node.val - prev.val);
+            }
+            prev = node;
+
+            dfs(node.right);
+        }
+    }
+
+    dfs(root);
+    return res;
+}