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

最新推荐文章于 2024-08-08 15:12:59 发布

m0_62262158

最新推荐文章于 2024-08-08 15:12:59 发布

阅读量425

点赞数 3

文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/m0_62262158/article/details/139920468

版权

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

链接

class Solution {
public:
    int res = INT_MAX;
    TreeNode* pre = nullptr;
    void traversal(TreeNode* cur) {
        if(cur == nullptr) {
            return;
        }
        traversal(cur->left);
        if(pre != nullptr) {
            res = min(res, cur->val - pre->val);
        }
        pre = cur;
        traversal(cur->right);
    }

    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return res;
    }
};

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        stack<TreeNode*> st;
        int minDiff = INT_MAX;
        TreeNode* cur = root, *pre = nullptr;
        while(cur || !st.empty()) {
            while(cur) {
                st.push(cur);
                cur = cur->left;
            }
            if(!st.empty()) {
                cur = st.top();
                st.pop();
                if(pre != nullptr) {
                    int diff = cur->val - pre->val;
                    minDiff = minDiff > diff ? diff : minDiff;
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return minDiff;
    }
};

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

链接

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode *node = root, *pre = nullptr;
        int maxNum = 0, num = 0;
        vector<int> vec;
        while (node || !st.empty()) {
            while (node) {
                st.push(node);
                node = node->left;
            }
            if (!st.empty()) {
                node = st.top();
                st.pop();
                if (pre == nullptr) {
                    num = 1;
                } else {
                    if (pre->val == node->val) {
                        num++;
                    } else {
                        num = 1;
                    }
                }

                if (num == maxNum) {
                    vec.push_back(node->val);
                } else if (num > maxNum) {
                    vec.clear();
                    vec.push_back(node->val);
                    maxNum = num;
                }
                pre = node;
                node = node->right;
            }
        }
        return vec;
    }
};

class Solution {
public:
    TreeNode* pre = nullptr;
    vector<int> vec;
    int maxNum;
    int num;
    void searchBST(TreeNode* cur) {
        if (cur == nullptr) {
            return;
        }
        searchBST(cur->left);
        if (pre == nullptr) {
            num = 1;
        } else {
            if (pre->val == cur->val) {
                num++;
            } else {
                num = 1;
            }
        }
        pre = cur;
        if (num == maxNum) {
            vec.push_back(cur->val);
        } else if (num > maxNum) {
            vec.clear();
            vec.push_back(cur->val);
            maxNum = num;
        }
        searchBST(cur->right);
        return ;
    }

    vector<int> findMode(TreeNode* root) {
        num = 0;
        maxNum = 0;
        pre = nullptr;
        vec.clear();
        searchBST(root);
        return vec;
        
    }
};