15 Jun 2024•C++ / Python / TypeScript•Easy

Minimum Absolute Difference in BST

Collected C++, Python, TypeScript solutions for minimum absolute difference in bst. Add a dedicated write-up later if you want deeper notes.

View original LeetCode question

auto-generated entry for Minimum Absolute Difference in BST. the solution files are available below.

solution files

C++ minimum-absolute-difference-in-bst/synced-solution.cpp
Python minimum-absolute-difference-in-bst/synced-solution.py
TypeScript minimum-absolute-difference-in-bst/synced-solution.ts

Solution files

Python•minimum-absolute-difference-in-bst/synced-solution.py

class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        prev = None
        answer = float(class="syntax-string">"inf")

        def inorder(node):
            nonlocal prev, answer
            if not node:
                return
            inorder(node.left)
            if prev is not None:
                answer = min(answer, node.val - prev)
            prev = node.val
            inorder(node.right)

        inorder(root)
        return answer

C++•minimum-absolute-difference-in-bst/synced-solution.cpp

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        prevSet = false;
        answer = INT_MAX;
        inorder(root);
        return answer;
    }

private:
    int prevValue;
    bool prevSet;
    int answer;

    void inorder(TreeNode* node) {
        if (!node) {
            return;
        }
        inorder(node->left);
        if (prevSet) {
            answer = min(answer, node->val - prevValue);
        }
        prevValue = node->val;
        prevSet = true;
        inorder(node->right);
    }
};

TypeScript•minimum-absolute-difference-in-bst/synced-solution.ts

function getMinimumDifference(root: TreeNode | null): number {
    let prev: number | null = null;
    let answer = Number.POSITIVE_INFINITY;

    const inorder = (node: TreeNode | null): void => {
        if (!node) {
            return;
        }
        inorder(node.left);
        if (prev !== null) {
            answer = Math.min(answer, node.val - prev);
        }
        prev = node.val;
        inorder(node.right);
    };

    inorder(root);
    return answer;
}