代码随想录算法训练营第21天 | Leetcode530.二叉搜索树的最小绝对差、Leetcode501.二叉搜索树中的众数

题目链接：530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

思路一：由于二叉搜索树的特性，进行中序遍历后所得到的是一个从小到大的有序数组，所以可以开辟一个数组空间，将元素依次有序放入后，再遍历一遍得到最小绝对差。

代码复现：

class Solution{
private:
vector<int> ret;
void search(TreeNode *root){
    if(root == NULL) return ;
    else{
    search(root->left);
    ret.push_back(root->val);
    search(root->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        int result = INT_MAX;
        search(root);
       //如果都没有两个结点那就不用说了
        if(ret.size() < 2)
        return 0;
       //注意这里循环的起始位置，因为是需要前后两个元素相减的  
        for(int i = 1; i < ret.size(); i++){ 
            result = min(result, ret[i] - ret[i-1]);
        }
        return result;
    }
};    

思路二：不需要格外开辟一个空间，运用双指针，一个指针指向前一个结点，一个指针指向后一个结点，用两个指针计算差

递归版本：

class Solution {
private: 
TreeNode* pre = NULL;
int result = INT_MAX;
void search(TreeNode *cur){
    if(cur == NULL)   return;
    search(cur->left);
    if(pre != NULL){
        result = min(result, cur->val - pre->val);
    }
   //移动指针！
    pre = cur;
    search(cur->right);
}
public:
    int getMinimumDifference(TreeNode* root) {
        search(root);
        return result;
    }
};

迭代版本：

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

主要就是中序遍历的两个版本

题目链接：501. 二叉搜索树中的众数 - 力扣（LeetCode）

思路：在树中用双指针前后比较

代码复现：记得移动指针！

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        int count = 0;
        int maxCount = 0;
        TreeNode *pre = NULL;
        TreeNode *cur = root;
        stack<TreeNode*> st;
        vector<int> ret;
        while(!st.empty() || cur != NULL){
            if(cur != NULL){
                st.push(cur);
                cur = cur->left;
            }
            else{
                cur = st.top();
                st.pop();
                if(pre == NULL){
                    count = 1;
                }
                else if(pre->val == cur->val){
                    count += 1;
                }
                else{
                     count = 1;   
                }
                //先判断是否等于再判断大小，否则会=不是只输出一个了
                if(count == maxCount){
                ret.push_back(cur->val);
                }
                if(count > maxCount){
                    ret.clear();    
                    maxCount = count;
                    ret.push_back(cur->val);
                }
                
            }
            return result;
        }
};

递归版本：

class Solution {
private:
TreeNode* pre = NULL;
vector<int> ret;
int count = 0, maxCount = 0;
void search(TreeNode *cur){
    if(cur == NULL) return;
    search(cur->left);
    if(pre == NULL){
    count = 1;
    }
    else if(pre->val == cur->val){
    count++;
    }
    else{
    count = 1;
    }    
    if(count == maxCount)
        ret.push_back(cur->val);
    if(count > maxCount){
        ret.clear();
        count = maxCount;
        ret.push_back(cur->val);
    }
    pre = cur;
    search(cur->right);    
}
public:
    vector<int> findMode(TreeNode* root) {
        search(root);
        return ret;
    }
};