代码随想录算法训练营第28天|LeetCode530.二叉搜索树的最小绝对差

代码随想录算法训练营第28天|LeetCode530.二叉搜索树的最小绝对差

1、LeetCode530.二叉搜索树的最小绝对差

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）
代码随想录 (programmercarl.com)

第一想法（递归）

递归遍历二叉搜索树，然后每个节点和自己的左右孩子节点比较，在这个过程中记录最小差。

写了代码，通过了大部分的测试用例，但是有未考虑到的情况。

思路是错的，这样不一定找的就是最小值。比如下面这种情况。

s

递归法1

采用中序遍历，将二叉树转化为一个有序数组，然后遍历有序数组找最小值。

class Solution {
public:
    vector<int> vec;
    void traversal(TreeNode* root){//中序遍历
        if(root == NULL)    return;
        if(root -> left){
            traversal(root->left);
        }
        vec.push_back(root->val);
        if(root -> right){
            traversal(root->right);
        }

    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        // vec是有序数组
        int res = 100005;
        for(int i=1 ; i< vec.size() ; i++){
            res = min(res,vec[i]-vec[i-1]);
        }
        return res;

    }
};

递归法2

在中序遍历的时候就进行计算，不借助vector数组。但是需要记录pre指针。

pre和cur指针写得不熟练。

class Solution {
public:
    int res = 100005;
    TreeNode* pre=NULL;
    void tra(TreeNode* cur){
        if(cur == NULL)    return;
        if(cur -> left){
            tra(cur->left);
        }
        // 看是否有pre
        if(pre != NULL){
            res = min(res,cur->val - pre->val);
        }
        pre = cur;//注意这一步，记录前一个
        if(cur -> right){
            tra(cur->right);
        }
    }
    int getMinimumDifference(TreeNode* root) {
        // 递归2 不借助vector
        tra(root);
        return res;
    }
};

迭代法

需要借助中序遍历的迭代写法。有点复杂下次再看吧！！

这个迭代写法不是统一的那个。

是day16中写的。先访问到最左，然后开始pop，pop的时候访问“中”。

class Solution {
public:
    int getMinimumDifference(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, cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};