Leetcode 15

最新推荐文章于 2024-07-20 22:34:59 发布

Zoeyii935

最新推荐文章于 2024-07-20 22:34:59 发布

阅读量154

点赞数

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

本文链接：https://blog.csdn.net/Zoeyii/article/details/133331679

版权

15. 3Sum（*）

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());

        for(int i=0; i<nums.size(); i++){
            if(nums[i] > 0) return res;
            if(i>0 && nums[i] == nums[i-1]) continue;

            int left = i+1;
            int right = nums.size()-1;
            while(left < right){
                if(nums[i]+nums[left]+nums[right] < 0){
                    left++;
                }else if(nums[i]+nums[left]+nums[right] > 0){
                    right--;
                }else{
                    vector<int> val = {nums[i], nums[left], nums[right]};
                    res.push_back(val);
                    while(left < right && nums[left] == nums[left+1]) left++;
                    while(left < right && nums[right] == nums[right-1]) right--;
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
};

1.确定思路

2.注意相等的时候，要while循环去掉一样的

637. Average of Levels in Binary Tree(OK)

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> res;

        que.push(root);

        while(!que.empty()){
            int size = que.size();
            double sum = 0;

            for(int i=0; i<size; i++){
                TreeNode* cur = que.front();
                sum += cur->val;
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            res.push_back(sum/(double)size);
        }
        return res;
    }
};

102. Binary Tree Level Order Traversal(OK)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;

        if(root != NULL) que.push(root);

        while(!que.empty()){
            int size = que.size();
            vector<int> levelNode;

            for(int i=0; i<size; i++){
                TreeNode* cur = que.front();
                que.pop();
                levelNode.push_back(cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            res.push_back(levelNode);
        }
        return res;
    }
};

103. Binary Tree Zigzag Level Order Traversal(想一下思路)

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        bool flag = true;
        if(root != NULL) que.push(root);

        while(!que.empty()){
            int size = que.size();
            vector<int> level;
            
            for(int i=0; i<size; i++){
                TreeNode* cur = que.front();
                que.pop();
                level.push_back(cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            if(!flag) reverse(level.begin(), level.end());
            flag = !flag;
            res.push_back(level);
        }
        return res;
    }
};

530. Minimum Absolute Difference in BST(想思路)

class Solution {
private:
    vector<int> res;
    void traversal(TreeNode* root){
        if(root == NULL) return;
        traversal(root->left);
        res.push_back(root->val);
        traversal(root->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        int minDif = INT_MAX;
        traversal(root);
        for(int i=1; i<res.size(); i++){
            minDif = min(minDif, res[i]-res[i-1]);
        }
        return minDif;
    }
};

230. Kth Smallest Element in a BST

class Solution {
private:
    vector<int> res;
    void traversal(TreeNode* root){
        if(root == NULL) return;
        traversal(root->left);
        res.push_back(root->val);
        traversal(root->right);
    }
public:
    int kthSmallest(TreeNode* root, int k) {
        traversal(root);
        return res[k-1];
    }
};

class Solution {
private:
    int res;
    int count;
    void traversal(TreeNode* root, int k){
        if(root == NULL) return;
        traversal(root->left, k);
        count++;
        if(count == k){
            res = root->val;
            return;
        }
        traversal(root->right, k);
    }
public:
    int kthSmallest(TreeNode* root, int k) {
        traversal(root, k);
        return res;
    }
};

98. Validate Binary Search Tree

1.(*)

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

2.(OK)

class Solution {
private:
    vector<int> res;
    void traversal(TreeNode* root){
        if(root == NULL) return;
        traversal(root->left);
        res.push_back(root->val);
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        traversal(root);

        for(int i=1; i< res.size(); i++){
            if(res[i] <= res[i-1]) return false;
        }
        return true;
    }
};