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

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
+}

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;
+};

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);
+ }
+ }
+}
+

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;
+}