每日一题day4：[LeetCode：HOT100 56、33、94、215、200、64、48]

每日一题day4：LeetCode

56. 合并区间

33. 搜索旋转排序数组

94. 二叉树的中序遍历

215. 数组中的第K个最大元素

200. 岛屿数量

64. 最小路径和

48. 旋转图像

---

1、56. 合并区间

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        int len = intervals.size();
        vector<vector<int>> ans;
        int l = intervals[0][0], r = intervals[0][1];
        for(int i = 1; i < len; i++){
            vector<int> temp = intervals[i];
            if(temp[0] <= r){
                r = max(r, temp[1]);
            }else{
                ans.push_back({l, r});
                l = temp[0], r = temp[1];
            }
        }
        ans.push_back({l, r});
        return ans;
    }
};

2、33. 搜索旋转排序数组

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int ans = -1;
        int l = 0, r = nums.size() - 1;
        while(l <= r){
            int mid = (l + r) >> 1;
            if(nums[mid] == target){
                ans = mid; break;
            }
            if(nums[l] <= nums[mid]){
                if(target >= nums[l] && target <= nums[mid]) r = mid - 1;
                else l = mid + 1;
            }else{
                if(target >= nums[mid] && target <= nums[r]) l = mid + 1;
                else r = mid - 1;
            }
        }
        return ans;
    }
};

3、94. 二叉树的中序遍历

/**
 * 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> inorderTraversal(TreeNode* root) {
        stack<TreeNode* > st;
        vector<int> ans;
        while(root || !st.empty()){
            while(root){
                st.push(root); root = root -> left;
            }
            root = st.top(); st.pop();
            ans.push_back(root -> val);
            root = root -> right;
        }
        return ans;
    }
};

4、215. 数组中的第K个最大元素

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int> que;
        for(int i = 0; i < nums.size(); i++) que.push(nums[i]);
        k--;
        while(k--) que.pop();
        return que.top();
    }
};

class Solution {
public:

    int slove(vector<int>& nums, int l, int r){
        int value = nums[l];
        while(l < r){
            while(l < r && nums[r] >= value) r--;
            nums[l] = nums[r];
            while(l < r && nums[l] <= value) l++;
            nums[r] = nums[l];
        }
        nums[l] = value;
        return l;
    }

    void Qsort(vector<int>& nums, int l, int r, int k, int& ans){
        if(l < r){
            int pos = slove(nums, l, r);
            if(pos == nums.size() - k){
                ans = nums[pos];
                return ;
            }else if(pos < nums.size() - k){
                Qsort(nums, pos + 1, r, k, ans);
            }else{
                Qsort(nums, l , pos - 1, k, ans);
            }
        }else{
            ans = nums[l];
            return ;
        }
    }

    int findKthLargest(vector<int>& nums, int k) {
        int ans = -1;
        Qsort(nums, 0, nums.size() - 1, k, ans);
        return ans;
    }
};

5、200. 岛屿数量

class Solution {
public:
    int n, m, ans = 0;
    int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    bool check(int x, int y, vector<vector<char>>& grid){
        if(x < 0 || x > n - 1 || y < 0 || y > m - 1) return false;
        if(grid[x][y] == '0') return false;
        return true;
    }
    void dfs(int x, int y, vector<vector<char>>& grid){
        grid[x][y] = '0';
        for(int i = 0; i < 4; i++){
            int nx = x + dir[i][0];
            int ny = y + dir[i][1];
            if(check(nx, ny, grid)) dfs(nx, ny, grid);
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        n = grid.size(); m = grid[0].size();
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == '1'){
                    dfs(i, j, grid);
                    ans++;
                }
            }
        }
        return ans;
    }
};

6、64. 最小路径和

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        for(int i = 1; i < n; i++) grid[i][0] += grid[i - 1][0];
        for(int j = 1; j < m; j++) grid[0][j] += grid[0][j - 1];
        for(int i = 1; i < n; i++){
            for(int j = 1; j < m; j++){
                grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j];
            }
        }
        return grid[n - 1][m - 1];
    }
};

7、48. 旋转图像

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int size = matrix.size();
        for(int i = 0; i < size; i++){
            for(int j = i + 1; j < size; j++){
                swap(matrix[i][j], matrix[j][i]);
            }
        }
        for(int i = 0; i < size; i++){
            for(int j = 0; j < size / 2; j++) swap(matrix[i][j], matrix[i][size - j - 1]);
        }
    }
};

---

2021/3/13完结。