二叉搜索树的最小绝对差

二叉搜索树的最小绝对差

给定一棵非负值的二叉搜索树，求任意两节点之差的绝对值的最小值。

考虑到二叉树的特性，要求差最小值的话就考虑当前节点和左子树的最大值（最右节点）和右子树的最小值（最左节点）的差值

class Solution {
    public int getMinimumDifference(TreeNode root) {
        int diff = Integer.MAX_VALUE;
        int left_diff = Integer.MAX_VALUE;
        int right_diff = Integer.MAX_VALUE;
        TreeNode cur;
        // 求与左子树最小差值
        if(root.left != null) {
            cur = root.left;
            while(cur.right != null) {
                cur = cur.right;
            }
            diff = Math.min(diff, Math.abs(root.val - cur.val));
        }
​
        // 求与右子树最小差值
        if(root.right != null) {
            cur = root.right;
            while(cur.left != null) {
                cur = cur.left;
            }
            diff = Math.min(diff, Math.abs(root.val - cur.val));
        }
​
        // 同求左子树和右子树
        if(root.left != null) {
            left_diff = getMinimumDifference(root.left);
        }
        if(root.right != null) {
            right_diff = getMinimumDifference(root.right);
        }
​
        // 返回
        return Math.min(diff, Math.min(left_diff, right_diff));
    }
}

另一种思路，搜索二叉树当作有序数组来看常常能产生一些不错的想法，这题也是一样，就是简单的求单调数组元素间的最小差值。

class Solution {
    public int getMinimumDifference(TreeNode root) {
        Stack<TreeNode> st = new Stack<>();
        st.push(root);
        int diff = Integer.MAX_VALUE;
        Integer pre = null;
        while(!st.isEmpty()) {
            TreeNode node = st.pop();
            if(node == null) {
                node = st.pop();
                if(pre == null) {
                    pre = node.val;
                } else {
                    diff = Math.min(diff, node.val - pre);
                    pre = node.val;
                }
                continue;
            }
            if(node.right != null) {
                st.push(node.right);
            }
            st.push(node);
            st.push(null);
            if(node.left != null) {
                st.push(node.left);
            }
        }
        return diff;
    }
}

看了解析还可以进一步改进，可以更优雅地使用递归，并且结合有序数组的思想

class Solution {
    TreeNode pre = null;
    int diff = Integer.MAX_VALUE;
    public int getMinimumDifference(TreeNode root) {
        getDifference(root);
        return diff;
    }
    public void getDifference(TreeNode node) {
        if(node.left != null) {
            getDifference(node.left);
        }
        if(pre != null) {
            diff = Math.min(diff, node.val - pre.val);
        }
        pre = node;
        if(node.right != null) {
            getDifference(node.right);
        }
    }
}