小山菌_代码随想录算法训练营第二十一天| 530.二叉搜索树的最小绝对差 、501. 二叉搜索树中的众数、 236. 二叉树的最近公共祖先

530.二叉搜索树的最小绝对差

文档讲解：代码随想录.二叉搜索树的最小绝对差

视频讲解：二叉搜索树中，需要掌握如何双指针遍历！| LeetCode：530.二叉搜索树的最小绝对差

状态：已完成

代码实现

/**
 * 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) {}
 * };
 */
/**
 * 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> nums;
    // void travsersl(TreeNode* root) {
    //     if (root == nullptr) {
    //         return;
    //     }
    //     travsersl(root->left);
    //     nums.push_back(root->val);
    //     travsersl(root->right);
    // }

    int result = INT_MAX;
    TreeNode* pre = nullptr;
    void travsersl(TreeNode* cur) {
        if (cur == nullptr) {
            return;
        }
        travsersl(cur->left);
        if (pre != nullptr) {
            result = min(result, cur->val - pre->val);
        }
        pre = cur;
        travsersl(cur->right);
    }

public:
    int getMinimumDifference(TreeNode* root) {
        // 第一种方法
        // nums.clear();
        // travsersl(root);
        // int result = INT_MAX;
        // for (int i = 1; i < nums.size(); i++) {

        //     result = result > (nums[i] - nums[i - 1]) ? nums[i] - nums[i - 1]
        //                                               : result;
        // }

        // return result;

        // 第二种方法
        travsersl(root);
        return result;
    }
};

心得体会

1. 有序二叉树采用中序遍历进行数据的读取，可以先转换成数组，再进行后续的操作，
2. 遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。
3. 同时要学会在递归遍历的过程中如何记录前后两个指针，这也是一个小技巧，学会了还是很受用的。

501. 二叉搜索树中的众数

文档讲解：代码随想录.二叉搜索树中的众数

视频讲解：不仅双指针，还有代码技巧可以惊艳到你！ | LeetCode：501.二叉搜索树中的众数

状态：已完成

代码实现

/**
 * 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 count = 0;
    int count_max = 0;
    vector<int> result;
    TreeNode* pre = NULL;
    void searshBST(TreeNode* cur) {

        if (cur == NULL) {
            return;
        }

        searshBST(cur->left); // 左中右遍历

        if (pre == NULL) {//这里的判断条件理解错误，应该是第一次走的时候的逻辑
            count = 1;
        } else if (pre->val == cur->val) {
            count++;

        } else {
            count = 1;
        }
        pre = cur;

        if (count == count_max) {
            result.push_back(cur->val);
        }

        if (count > count_max) {
            count_max = count;
            result.clear();
            result.push_back(cur->val);
        }

        searshBST(cur->right);
        return;
    }

public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        count_max = 0;
        pre = NULL;
        result.clear();
        searshBST(root);
        return result;
    }
};

心得体会

1. 在第一次写的时候，忽略了第一次走循环的判断条件，导致调试失败
2. 另外本文还以后另外两种方法，需要花时间仔细品味一下

236. 二叉树的最近公共祖先

文档讲解：代码随想录.二叉树的最近公共祖先

视频讲解：自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先

状态：已完成

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {

        // 中止条件
        if (root == p || root == q || root == NULL) {
            return root;
        }

        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);

        if (left != NULL && right != NULL) {
            return root;
        }//这个条件遗漏了

        if (left == NULL && right != NULL) {
            return right;

        } else if (left != NULL && right == NULL) {
            return left;

        } else { // left ==NULL right == NULL
            return NULL;
        }
    }
};

心得体会

1. 目前来说根据视频可以理解，也可以通过记忆进行复现，但是总感觉有地方没有吃透，需要自己进行适当的整理和总结
2. 注意事项

那么二叉树如何可以自底向上查找呢？

回溯啊，二叉树回溯的过程就是从低到上。

后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。