[代码随想录算法训练营]刷题笔记 Day 21

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

class Solution {
private:
    int minDiff = INT32_MAX;
    TreeNode* pre = NULL;

    // 中序遍历，可以让我们得到有序的序列
    void traverse(TreeNode* cur){
        // 终止条件，若为空节点
        if(!cur) return;

        // 左边，先遍历左边取得pre值(pre值在中间处理逻辑赋值)
        traverse(cur->left);

        // 中间，因为pre是左值必定小于中值，所以(cur - pre)必大于0
        if(pre){
            minDiff = min(minDiff, cur->val - pre->val);
        }
        //　给pre赋值
        pre = cur; 

        // 右边
        traverse(cur->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traverse(root);
        return minDiff;
    }
};

501.二叉搜索树中的众数

二叉搜索树就用中序遍历。还不是很熟炼药多练

//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
	TreeNode* pre = NULL;
	int count = 0;
	int maxCount = 0;
	vector<int> result;

	void traverse(TreeNode* cur){
		if(!cur) return;

		// 遍历左子树
		traverse(cur->left);

		// 遍历当前节点
		if(!pre) count = 1;
		else if(cur->val == pre->val) count++;
		else if(cur->val != pre->val) count = 1;
		pre = cur; // 更新上一个节点

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

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

		// 遍历右子树
		traverse(cur->right);
	}
public:
    vector<int> findMode(TreeNode* root) {
		traverse(root);
    	return result;
    }
};

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

很直观的想法是，找到p与q然后向上遍历，找到相同的祖先。正常的二叉树，都是向下遍历的，如果要向上遍历，只有一种情况：回溯。而回溯必定是用到后序遍历。
这个题目里会出现两种情况p与q有共同祖先，或者p或q干脆其中一个就是两者的祖先。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 判断传入为空节点
        if(!root) 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; // 两边都没有找到目标
    }
};