[ 二叉树 ] 二叉搜索树的最小绝对差

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode） (leetcode-cn.com)

二叉搜索树的最小绝对差

递归

• 二叉搜索树的**中序遍历结果是严格递增**的
• 保存中序遍历向量再处理

class Solution {
public:
    // 向量保存中序遍历结果
    vector<int> value;
    
    // 中序遍历
    void traversal(TreeNode* root) {
        if (!root) return;
        traversal(root->left);
        value.emplace_back(root->val);
        traversal(root->right);
    }
    
	// 求向量相邻两数绝对值差的最小值
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        int ans = INT_MAX;
        for (int i = 0; i < value.size() - 1; ++i) {
            ans = min(ans, value[i + 1] - value[i]);
        }
        return ans;
    }
};

• 保存上次访问，直接处理差值

class Solution {
public:
    int ans = INT_MAX;
    TreeNode* pre;
    
    void traversal(TreeNode* cur) {
        if (!cur) return;
      	// 中序
        traversal(cur->left);
        if (!pre) ans = min(ans, cur->val - pre->val);
  		// 保存上次访问
        pre = cur;
        traversal(cur->right);
    }
    
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return ans;
    }
};

非递归

• 二叉搜索树的**中序遍历结果是严格递增**的

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        int Min = INT_MAX;
        vector<int> value;
        stack<TreeNode*> stk;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            stk.pop();
            if (node) {
                if (node->right) stk.push(node->right);
                stk.push(node);
                stk.push(nullptr);
                if (node->left) stk.push(node->left);
            }
            // 只修改处理部分即可
            else {
                node = stk.top();
                stk.pop();
                value.emplace_back(node->val);
            }
        }
        // 找到数组中的最小值即可
        for (int i = 0; i < value.size() - 1; i++) {
            Min = min(Min, value[i + 1] - value[i]);
        }
        return Min;
    }
};