代码随想录day18

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

//耗时巨长写法

    int min = INT_MAX;
    int getMinimumDifference(TreeNode* root) {
        queue<TreeNode*> qe;
        if(root == nullptr){
            return 0;
        }
        qe.push(root);
        vector<vector<int>> result;
        while(!qe.empty()){
            int sz = qe.size();
            vector<int> tmp;
            for(int i = 0; i < sz; i++){
                TreeNode* node = qe.front();
                qe.pop();
                tmp.push_back(node->val);
                if(node->left) qe.push(node->left);
                if(node->right) qe.push(node->right);
            }
            result.push_back(tmp);
        }
        for(int j = 0; j < result.size()-1; j++){
            vector<int> pre = result[j];
            for(int k = j+1; k < result.size(); k++){
                vector<int> now = result[k];
                for(int m = 0; m < pre.size(); m++){
                    int tmp_pre = pre[m];
                    for(int n = 0; n < now.size(); n++){
                        int tmp_now = now[n];
                        if(abs(tmp_pre-tmp_now) < min){
                            min = abs(tmp_pre-tmp_now);
                        }
                    }
                }
            }
        }
        return min;
    }

//理解二叉搜索树的含义，以及双指针法记录前序指针的写法

    int result = INT_MAX;
    TreeNode* pre = nullptr;
    void traverse(TreeNode* node){
        if(node == nullptr){
            return;
        }
        traverse(node->left);
        if(pre){
            result = min(result, abs(node->val - pre->val));
        }
        pre = node;
        traverse(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traverse(root);
        return result;
    }

501.二叉搜索树中的众数，需二刷，理解双指针及如何求众数

    vector<int> result;
    TreeNode* prev;
    int max_count = 0;
    int count = 0;
    void traverse(TreeNode* node){
        if(node == nullptr) return;
        traverse(node->left);
        if(prev == nullptr){
            count = 1;
        }else if(prev->val == node->val){
            count += 1;
        }else{
            count = 1;
        }
        prev = node;
        if(count > max_count){
            max_count = count;
            result.clear();
            result.push_back(node->val);
        }else if (count == max_count){
            result.push_back(node->val);
        }
        traverse(node->right);
    }
    vector<int> findMode(TreeNode* root) {
        traverse(root);
        return result;
    }

236.二叉树的最长公共祖先，需二刷

//左右中后序遍历，回溯来实现由底向上遍历，找到公共祖先

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr){
            return nullptr;
        }
        if(root == p || root == q){
            return root;
        }
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if(left != nullptr && right != nullptr){
            return root;
        }else if(left == nullptr && right != nullptr){
            return right;
        }else if(left != nullptr && right == nullptr){
            return left;
        }else{
            return nullptr;
        }
    }