C++刷题笔记(25)——leetcode530、501

题目1：530.二叉搜索树的最小绝对差

解法一：中序遍历

利用数组：
在98.验证二叉搜索树中就有利用二叉搜索树输出数组的升序性，这里也可以通过输出数组，转换成在有序数组上求两个数的最小差值。

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) {
        traversal(root);
        if (vec.size() < 2) return 0;
        int result = INT_MAX;
        for (int i = 1; i < vec.size(); i++) { // 统计有序数组的最小差值
            result = min(result, vec[i] - vec[i-1]);
        }
        return result;
    }
};

利用指针：
利用两个指针，一个记录当前节点、一个记录前一个节点
在遍历过程中一边遍历一边更新答案，不用再创建数组来保存

class Solution {
public:
    int result = INT_MAX;
    TreeNode* pre;                    //指向前一个节点
    void traversal(TreeNode* cur) {   //指向当前节点
        if(cur==NULL) return;
        traversal(cur->left);         //左
        if (pre != NULL) result = min(result, cur->val - pre->val);  //中
        pre = cur;
        traversal(cur->right);        //右
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

解法二：迭代法

同样是用栈模仿中序遍历

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* pre = NULL;
        TreeNode* cur = root;
        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;
    }
};

题目2：501.二叉搜索树中的众数

解法一：递归法

同样是使用两个指针，cur指向当前节点、pre指向当前节点的前一个节点，然后中序遍历二叉搜索树，因为加入了众数，所以原本遍历的升序大于结构变成了大于等于，因此就比较相邻元素出现的频率，将频率最大的数放入结果中

class Solution {
public:
    int maxcount = 0;                                          //最大频率
    int count = 0;                                             //当前元素出现的频率
    TreeNode* pre=NULL;                                        //记录前一个节点，初始化为NULL，当pre=null时可知此时比较的是第一个节点
    vector<int> result;
    void searchBST(TreeNode* cur) {                            //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.push_back(cur->val);     //如果和最大值相同，放入result中，众数可能有多个
        if (count > maxcount) {                                //如果计数大于最大值频率
            maxcount = count;                                  //更新最大频率
            result.clear();                                    //清空result，之前result中的元素都失效
            result.push_back(cur->val);                        //将当前节点的值放入result
        }
        searchBST(cur->right);                                 //右
        return;
    }
    vector<int> findMode(TreeNode* root) {
        searchBST(root);
        return result;
    }
};