The main idea was to apply in-order traversal to the BST.
One key observation is that for a triad of nodes, one only has to compare the left and right child to its parent. There is no need to check the difference between the left child and right child because it is a BST, meaning that the difference between these two children must be larger than that between a child and its parent.

Moreover, suppose we’ve already known the min difference of this triad of nodes, then we only need to compare the right child to its grandparent (if there is one) cuz that is the only possibility that generates a smaller difference.

The traversal order of in-order traversal perfectly solves this problem. First, we traverse the BST to its leftmost child and memorize its value to a variable, say previous. Then, the in-order traversal would lead us to its parent, which enables us to calculate the difference between these two nodes. After the calculation, we change the value of the variable to the value of the parent. Following the traversal order, we reach the right child and calculate the difference, compare it with the one we calculated in the previous step, and set the prev to the value of the right child. In the next phase, we are able to calculate the difference between the right child and its grandparent. These are all calculations required to find the minimum difference in the BST.

Following is a potential solution to this problem:

class Solution {
    Integer res; 
    Integer prev;

    public int minDiffInBST(TreeNode root) {
        res = Integer.MAX_VALUE;
        prev = null;
        inorder(root);
        return res;
    }

    public void inorder(TreeNode root) {
        if
 
(root == null) return;
        inorder(root.left);
        if(prev !=  null){
            res = Math.min(res, root.val - prev);
        }
        prev = root.val;
        inorder(root.right);
    }
}