代码随想录算法训练营第二十一天

代码随想录算法训练营第二十一天

一、530.二叉搜索树的最小绝对值

​ 二叉搜索树是有序的，可以将二叉搜索树转换成有序数组，然后遍历数组来统计最小差值。

​ 而采用双指针法的话，中序遍历一遍数组也能统计出最小差值。

class Solution {
private:
int result = INT_MAX;
TreeNode* pre = NULL;
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);  // 右
}
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

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

​ 要注意vector.clear( )操作，可以清空vector容器，而不是采用pop_back( )方式。

class Solution {
public:
    int count = 0;
    int max_count = 0;
    TreeNode* pre = NULL;
    vector<int> result;
    void traversal(TreeNode* node){
        if(node == NULL)    return ;

        traversal(node->left);

        if(pre == NULL){
            count = 1;
        }
        else if(pre->val == node->val){
            count++;
        }
        else
            count = 1;

        pre = node;
        if(count == max_count){
            result.push_back(node->val);
        }
        if(count > max_count){
            max_count = count;
            result.clear();
            result.push_back(node->val);
        }
        
        
        traversal(node->right);
        return ;
    }
    vector<int> findMode(TreeNode* root) {
        count = 0;
        max_count = 0;
        result.clear();
        TreeNode* pre = NULL;
        traversal(root);
        return result;
    }
};

​ 如果二叉树不是二叉搜索树，即无序的。可以采用map统计出现的频次，然后就map的value进行排序，取频次最大的key。

class Solution {
private:

void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
    if (cur == NULL) return ;
    map[cur->val]++; // 统计元素频率
    searchBST(cur->left, map);
    searchBST(cur->right, map);
    return ;
}
bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
    return a.second > b.second;
}
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map; // key:元素，value:出现频率
        vector<int> result;
        if (root == NULL) return result;
        searchBST(root, map);
        vector<pair<int, int>> vec(map.begin(), map.end());
        sort(vec.begin(), vec.end(), cmp); // 给频率排个序
        result.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); i++) {
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

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

​ 这题有点没想清楚，但容易想到的是自底向上的遍历，也就是用后序遍历的方式。但是对于“中”的处理逻辑没想明白，看了讲解清晰多了。

class Solution {
public:
    TreeNode* traversal(TreeNode* node, TreeNode* p, TreeNode* q){
        if(node == NULL || node == p || node == q)  return node;

        TreeNode* leftNode = traversal(node->left, p, q);
        TreeNode* rightNode = traversal(node->right, p, q);

        if(!leftNode && !rightNode) return NULL;
        if(leftNode && !rightNode)  return leftNode;
        if(!leftNode && rightNode)  return rightNode;
        return node;

    };
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return traversal(root, p, q);
    }
};