随想录一刷Day20——二叉树

Day20_二叉树

23. 验证二叉搜索树

98. 验证二叉搜索树
思路：

要验证二叉搜索树就要满足左子树的所有结点小于根节点，右子树的所有节点大于根节点

错误写法：
这里误以为只判断左子节点小于根节点，右子节点大于根节点就够了，忽略了左子树的所有结点都必须小于根节点，右子树同理。下面是一开始错误写法的代码。

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        if (root->left != NULL && root->left->val >= root->val) return false;
        if (root->right != NULL && root->right->val <= root->val) return false; 
        
        return isValidBST(root->left) && isValidBST(root->right);
    }
};

写法二：
正确写法应该是判断左子树的所有节点都小于根节点，右子树的所有结点都大于根节点。
这里利用中序遍历的性质，中序遍历下，二叉搜索树的遍历结果单调递增。

class Solution {
public:
    TreeNode* pre = NULL; // 记录前一个结点，方便中序遍历时判断递增
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true; // 空结点也是二叉搜索树
        bool left = isValidBST(root->left); // 左

        if (pre && pre->val >= root->val) return false; // 中
        pre = root;

        bool right = isValidBST(root->right); // 右

        return left && right;
    }
};

写法三：
迭代法

class Solution {
public:
    TreeNode* pre = NULL; // 记录前一个结点，方便中序遍历时判断递增
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        while (cur != NULL || !stk.empty()) { // 节点未遍历完或者栈不为空
            if (cur != NULL) { // 左
                stk.push(cur);
                cur = cur->left;
            } else {
                cur = stk.top(); // 中
                stk.pop();
                if (pre != NULL && pre->val >= cur->val) return false;
                pre = cur;

                cur = cur->right; // 右
            }
        }
        return true;
    }
};

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

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

由于二叉搜索树的中序遍历结果是单调递增的，最小差值一定在遍历结果的相邻值之间产生。

写法一：递归

class Solution {
public:
    TreeNode* pre = NULL; // 记录中序遍历的前一个结点
    int ans = INT_MAX;
    int getMinimumDifference(TreeNode* root) {
        if (root == NULL) return INT_MAX;
        getMinimumDifference(root->left);
        
        if (pre) ans = min(ans, root->val - pre->val); // 中序遍历相邻结果
        pre = root;
        
        getMinimumDifference(root->right);

        return ans;
    }
};

写法二：迭代

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        TreeNode* pre = NULL; // 记录中序遍历的前一个结点
        int ans = INT_MAX;

        while (cur || !stk.empty()) {
            if (cur) {
                stk.push(cur);
                cur = cur->left;
            } else {
                cur = stk.top(); stk.pop();
                if (pre) ans = min(ans, cur->val - pre->val);
                pre = cur;

                cur = cur->right;
            }
        }

        return ans;
    }
};

25. 二叉搜索树中的众数

501. 二叉搜索树中的众数
思路：

前中后序遍历均可，得到遍历结果后，对结果排序，选出众数。
方便起见，对BST使用中序遍历，其结果为不降序排列，免去排序步骤，直接选择众数结果即可。

class Solution {
private:
    TreeNode* pre = NULL;
    int count = 0;
    int max_count = 0;
    vector<int> ans;
    void traversal(TreeNode* root) {
        if (root == NULL) return ;
        traversal(root->left);

        if (pre == NULL) count = 1;
        else if (pre->val == root->val) count++;
        else count = 1;
        pre = root;

        if (count == max_count) ans.push_back(root->val);
        else if (count > max_count) {
            max_count = count;
            ans.clear();
            ans.push_back(root->val);
        }

        traversal(root->right);
    }

public:
    vector<int> findMode(TreeNode* root) {
        count = max_count = 0;
        ans.clear();
        traversal(root);
        return ans;
    }
};