LeetCode783. 二叉搜索树节点最小距离(day0016_3)

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

示例 1：

 输入：root = [4,2,6,1,3]
 输出：1

示例 2：

 输入：root = [1,0,48,null,null,12,49]
 输出：1

提示：

• 树中节点的数目范围是 [2, 100]

• 0 <= Node.val <= 105

递归法（定义数组）：

/**
 * 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 {
private:
    vector<int>vec;
    void traversal(TreeNode* root){
        if(root==NULL)return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        traversal(root);
        if(vec.size()<2)return 0;
        int result=INT_MAX;
        for(int i=1;i<vec.size();i++){
            result=min(result,abs(vec[i]-vec[i-1]));//统计有序数组的最小差值,用绝对值
        }
        return result;
    }
};

递归法（简洁版）：

/**
 * 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 {
private:
    int result=INT_MAX;
    TreeNode* pre;
    void traversal(TreeNode* root){
        if(root==NULL)return;
        traversal(root->left);//左
        if(pre!=NULL)result=min(result,abs(root->val-pre->val));//中，加绝对值
        pre=root;//记录前一个指针
        traversal(root->right);//右
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

迭代法：

/**
 * 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:
    int minDiffInBST(TreeNode* root) {
        //建立栈，用来存储遍历节点
        stack<TreeNode*>st;
        //建立指针，用来遍历节点
        TreeNode* cur=root;
        //建立前节点，用来算差值
        TreeNode* pre=NULL;
        //建立变量用来存放最小值
        int result=INT_MAX;
        //中序遍历二叉搜索树
        while(cur!=NULL||!st.empty()){
            //遍历到左叶子
            if(cur!=NULL){
                st.push(cur);
                cur=cur->left;//左
            }else{
                cur=st.top();
                st.pop();
                if(pre!=NULL){
                    result=min(result,abs(cur->val-pre->val));//中，要加绝对值
                }
                pre=cur;
                cur=cur->right;//右
            }
        }
        return result;
    }
};