Welcome to Subscribe On Youtube

530. Minimum Absolute Difference in BST

Description

Given the root of a Binary Search Tree (BST), return the minimum absolute difference between the values of any two different nodes in the tree.

 

Example 1:

Input: root = [4,2,6,1,3]
Output: 1

Example 2:

Input: root = [1,0,48,null,null,12,49]
Output: 1

 

Constraints:

  • The number of nodes in the tree is in the range [2, 104].
  • 0 <= Node.val <= 105

 

Note: This question is the same as 783: https://leetcode.com/problems/minimum-distance-between-bst-nodes/

Solutions

  • /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode() {}
     *     TreeNode(int val) { this.val = val; }
     *     TreeNode(int val, TreeNode left, TreeNode right) {
     *         this.val = val;
     *         this.left = left;
     *         this.right = right;
     *     }
     * }
     */
    class Solution {
        private int ans;
        private int prev;
        private int inf = Integer.MAX_VALUE;
    
        public int getMinimumDifference(TreeNode root) {
            ans = inf;
            prev = inf;
            dfs(root);
            return ans;
        }
    
        private void dfs(TreeNode root) {
            if (root == null) {
                return;
            }
            dfs(root.left);
            ans = Math.min(ans, Math.abs(root.val - prev));
            prev = root.val;
            dfs(root.right);
        }
    }
    
  • /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
     * };
     */
    class Solution {
    public:
        const int inf = INT_MAX;
        int ans;
        int prev;
    
        int getMinimumDifference(TreeNode* root) {
            ans = inf, prev = inf;
            dfs(root);
            return ans;
        }
    
        void dfs(TreeNode* root) {
            if (!root) return;
            dfs(root->left);
            ans = min(ans, abs(prev - root->val));
            prev = root->val;
            dfs(root->right);
        }
    };
    
  • # Definition for a binary tree node.
    # 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: TreeNode) -> int:
            def dfs(root):
                if root is None:
                    return
                dfs(root.left)
                nonlocal ans, prev
                ans = min(ans, abs(prev - root.val))
                prev = root.val
                dfs(root.right)
    
            ans = prev = inf
            dfs(root)
            return ans
    
    
  • /**
     * Definition for a binary tree node.
     * type TreeNode struct {
     *     Val int
     *     Left *TreeNode
     *     Right *TreeNode
     * }
     */
    func getMinimumDifference(root *TreeNode) int {
    	inf := 0x3f3f3f3f
    	ans, prev := inf, inf
    	var dfs func(*TreeNode)
    	dfs = func(root *TreeNode) {
    		if root == nil {
    			return
    		}
    		dfs(root.Left)
    		ans = min(ans, abs(prev-root.Val))
    		prev = root.Val
    		dfs(root.Right)
    	}
    	dfs(root)
    	return ans
    }
    
    func abs(x int) int {
    	if x < 0 {
    		return -x
    	}
    	return x
    }
    
  • // Definition for a binary tree node.
    // #[derive(Debug, PartialEq, Eq)]
    // pub struct TreeNode {
    //   pub val: i32,
    //   pub left: Option<Rc<RefCell<TreeNode>>>,
    //   pub right: Option<Rc<RefCell<TreeNode>>>,
    // }
    //
    // impl TreeNode {
    //   #[inline]
    //   pub fn new(val: i32) -> Self {
    //     TreeNode {
    //       val,
    //       left: None,
    //       right: None
    //     }
    //   }
    // }
    use std::rc::Rc;
    use std::cell::RefCell;
    impl Solution {
        #[allow(dead_code)]
        pub fn get_minimum_difference(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
            let mut ret = i32::MAX;
            let mut prev = i32::MAX;
            Self::traverse(root, &mut prev, &mut ret);
            ret
        }
    
        #[allow(dead_code)]
        fn traverse(root: Option<Rc<RefCell<TreeNode>>>, prev: &mut i32, ans: &mut i32) {
            let left = root.as_ref().unwrap().borrow().left.clone();
            let right = root.as_ref().unwrap().borrow().right.clone();
            let val = root.as_ref().unwrap().borrow().val;
            if !left.is_none() {
                Self::traverse(left.clone(), prev, ans);
            }
            *ans = std::cmp::min(*ans, (*prev - val).abs());
            *prev = val;
            if !right.is_none() {
                Self::traverse(right.clone(), prev, ans);
            }
        }
    }
    
    
  • /**
     * Definition for a binary tree node.
     * 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)
     *     }
     * }
     */
    function getMinimumDifference(root: TreeNode | null): number {
        if (!root) return 0;
    
        let prev = Number.MIN_SAFE_INTEGER;
        let min = Number.MAX_SAFE_INTEGER;
    
        const dfs = (node: TreeNode | null) => {
            if (!node) return;
    
            dfs(node.left);
            min = Math.min(min, node.val - prev);
            prev = node.val;
            dfs(node.right);
        };
    
        dfs(root);
    
        return min;
    }
    
    
  • /**
     * 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 getMinimumDifference = function (root) {
        let [ans, pre] = [Infinity, -Infinity];
        const dfs = root => {
            if (!root) {
                return;
            }
            dfs(root.left);
            ans = Math.min(ans, root.val - pre);
            pre = root.val;
            dfs(root.right);
        };
        dfs(root);
        return ans;
    };
    
    

All Problems

All Solutions