day21 第六章二叉树

风华正茂，挥斥方遒

于 2022-11-15 16:20:58 发布

阅读量87

点赞数

分类专栏： leetcode 文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/studyingforever666/article/details/127868255

版权

二叉搜索树最小绝对差众数最近公共祖先中序遍历

关键词由CSDN通过智能技术生成

leetcode 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

第六章二叉树

1.今日内容

0530之二叉搜索树的最小绝对差
 0501之二叉搜索树中的众树
 0236之二叉树的最近公共祖先
第三道需要可以再刷一次。

2.实现代码

[0530之二叉搜索树的最小绝对差]

/**
 * 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 {
public:
    int getMinimumDifference(TreeNode* root) {
        if (root == nullptr || (root->left == nullptr && root->right == nullptr)) return -1;
        int absMin = INT_MAX;
        TreeNode* prev = nullptr;
        InOrderTraverse(root, prev, absMin);
        return absMin;
    }
private:
    void InOrderTraverse(TreeNode* root, TreeNode* &prev, int &absMin) {
        if (root == nullptr) return;
        InOrderTraverse(root->left, prev, absMin);
        if (prev != nullptr) absMin = min(absMin, root->val - prev->val);
        prev = root;
        InOrderTraverse(root->right, prev, absMin);
    }
};

[0501之二叉搜索树中的众树]


/**
 * 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 {
public:
    vector<int> findMode(TreeNode* root) {
        vector<int> result;
        TreeNode* prev = nullptr;
        int cnt = 0;
        int maxcnt = 0;
        InOrderTraverse(root, prev, cnt, maxcnt, result);
        return result;
    }
private:
    void InOrderTraverse(TreeNode* root, TreeNode* &prev, int &cnt, int &maxcnt, vector<int> &result) {
        if (root == nullptr) return;
        InOrderTraverse(root->left, prev, cnt, maxcnt, result);
        if (prev == nullptr)             cnt = 1;
        else if (prev->val != root->val) cnt = 1;
        else                             ++ cnt;
        prev = root;
        if (cnt > maxcnt) {
            result.clear();
            result.push_back(root->val);
            maxcnt = cnt;
        } else if (cnt == maxcnt) {
            result.push_back(root->val);
        }
        InOrderTraverse(root->right, prev, cnt, maxcnt, result);
    }
};

[0236之二叉树的最近公共祖先]


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr || p == nullptr || q == nullptr) return nullptr;
        if (root == p || root == q) return root;  // p,q在一条叶子结点到根结点的路径上时
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if (left != nullptr && right != nullptr) return root;  // 当左右子树都不为空时一定是其最近公共祖先
        if (left == nullptr) return right;
        return left;
    }
};