Approach: Inorder traversal of a BST is sorted; scan adjacent differences

def getMinimumDifference(self, root):
    self.prev = None; self.best = float("inf")
    def inorder(node):
        if not node: return
        inorder(node.left)
        if self.prev is not None:
            self.best = min(self.best, node.val - self.prev)
        self.prev = node.val
        inorder(node.right)
    inorder(root)
    return self.best

Complexity: O(n) time, O(h) space.

Full Solution — all languages

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def getMinimumDifference(self, root):
        self.prev = None; self.best = float("inf")
        def inorder(node):
            if not node: return
            inorder(node.left)
            if self.prev is not None:
                self.best = min(self.best, node.val - self.prev)
            self.prev = node.val
            inorder(node.right)
        inorder(root)
        return self.best

import java.util.*;
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) {
        val = v;
    }
}
class Solution {
    public int getMinimumDifference(TreeNode root) {
        prev = 0;
        has = false;
        best = Integer.MAX_VALUE;
        inorder(root);
        return best;
    }
    long prev;
    boolean has;
    int best;
    private void inorder(TreeNode node) {
        if (node == null) return;
        inorder(node.left);
        if (has) best = Math.min(best, (int)(node.val - prev));
        prev = node.val;
        has = true;
        inorder(node.right);
    }
}

#include <bits/stdc++.h> using namespace std;
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {
    }
};
class Solution {
    public: int getMinimumDifference(TreeNode* root) {
        long long prev = 0;
        bool has = false;
        int best = INT_MAX;
        function<void(TreeNode*)> inorder = [&](TreeNode* node) {
            if (!node) return;
            inorder(node->left);
            if (has) best = min(best, (int)(node->val - prev));
            prev = node->val;
            has = true;
            inorder(node->right);
        };
        inorder(root);
        return best;
    }
};

/**
 * Tree node shape: { val, left, right }
 * @param {TreeNode} root
 * @return {number}
 */ var getMinimumDifference = function(root) {
    let prev = null, best = Infinity;
    const inorder = (node) => {
        if (!node) return;
        inorder(node.left);
        if (prev !== null) best = Math.min(best, node.val - prev);
        prev = node.val;
        inorder(node.right);
    };
    inorder(root);
    return best;
};

Minimum Absolute Difference in BST

Example 1

Example 2

Constraints