代码随想录第18天：530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

530.二叉搜索树的最小绝对差：注意利用二叉搜索树中序遍历有序的特点，代码如下：

// 二叉搜索树的最小差值

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void Traversal(TreeNode *root, vector<int> &vec)
{
    if (root == NULL)
        return;
    Traversal(root->left, vec);
    vec.push_back(root->val);
    Traversal(root->right, vec);
}

int getMinDif(TreeNode *root)
{
    vector<int> vec;
    int res = INT_MAX;
    Traversal(root, vec);
    for (int i = 1; i < vec.size(); i++)
    {
        res = min(res, vec[i] - vec[i - 1]);
    }
    return res;
}

int main()
{
    TreeNode *t2 = new TreeNode(1);
    t2->right = new TreeNode(3);
    t2->right->left = new TreeNode(2);

    int a = getMinDif(t2);
    cout << a << endl;
    return 0;
}

501.二叉搜索树中的众数：利用二叉搜索树的特点，众数一定是相邻的，记录中序遍历时的遍历上下节点来实现代码，代码如下：

// 501.二叉搜索树中的众数

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

int maxCount = 0; // 最大频率
int count = 0;    // 统计频率
TreeNode *pre = NULL;
vector<int> result;

void searchBST(TreeNode *cur)
{
    if (cur == NULL)
        return;

    searchBST(cur->left); // 左
                          // 中
    if (pre == NULL)
    { // 第一个节点
        count = 1;
    }
    else if (pre->val == cur->val)
    { // 与前一个节点数值相同
        count++;
    }
    else
    { // 与前一个节点数值不同
        count = 1;
    }
    pre = cur; // 更新上一个节点

    if (count == maxCount)
    { // 如果和最大值相同，放进result中
        result.push_back(cur->val);
    }

    if (count > maxCount)
    {                     // 如果计数大于最大值频率
        maxCount = count; // 更新最大频率
        result.clear();   // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
        result.push_back(cur->val);
    }

    searchBST(cur->right); // 右
    return;
}

vector<int> findMode(TreeNode *root)
{
    count = 0;
    maxCount = 0;
    pre = NULL; // 记录前一个节点
    result.clear();

    searchBST(root);
    return result;
}

int main()
{
    TreeNode *t2 = new TreeNode(1);
    t2->right = new TreeNode(2);
    t2->right->left = new TreeNode(2);

    vector<int> res = findMode(t2);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl;
    return 0;
}

236. 二叉树的最近公共祖先：利用回溯思想，当遍历到相同值时返回，因为是自下而上找所以用后序遍历

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

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode *lowestCommonAncestor(TreeNode *root, int p, int q)
{
    if (root->val == p || root->val == 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
    {
        return NULL;
    }
}

int main()
{
    TreeNode *t2 = new TreeNode(3);
    t2->left = new TreeNode(5);
    t2->left->left = new TreeNode(6);
    t2->left->right = new TreeNode(2);
    t2->left->right->left = new TreeNode(7);
    t2->left->right->right = new TreeNode(4);

    t2->right = new TreeNode(1);
    t2->right->left = new TreeNode(0);
    t2->right->right = new TreeNode(8);

    TreeNode *res = lowestCommonAncestor(t2, 5, 1);
    cout << res->val << endl;

    return 0;
}