Leetcode刷题——数组

以为读博就能躲过算法的控制，但是万万没想到考核也有机试。身边的同学找工作，算法是第一步，越来越意识到，算法作为CS人的重要性。如果说学历是敲门砖，算法能力就是入场券，那就继续坚持刷题吧！！ 我选择的语言是C++,从githua上找到了每个专题下比较经典的题目，那就按照这个顺序来刷吧！！

一、数组

1. 移动0

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int len = nums.size();
        if(nums.size()==1) return;
        int count = 0;
        for(int i=0;i<len;i++){
            if(nums[i]==0){  //判断是否为0
                count++;
            }
            else{            //不为0的元素根据前面0的个数，向前移动至最终的位置
                nums[i-count]=nums[i];
            }
        } 
        //将0元素全部放在数组的后面
        for(int j=len-count; j<len;j++){
            nums[j]=0;
        }
    }
};

2. 重塑矩阵

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        int row = mat.size();
        int col = 0;
        if(row>0){
             col = mat[0].size(); 
        }
        // 先判断给的r,c是否合理,(一开始我整的花里胡哨的好几个条件，实际上一个条件就能cover到所有种条件)
        if(row*col != r*c) return mat;
        vector<vector<int>> res(r,vector<int>(c));
        int oldcol,oldrow,newcol,newrow;
        //对于一个一维数组，其第i个元素在矩阵中的索引与列相关，行索引：i/列大小，列索引：i%列大小 （就这一个简单的数学问题，我半天也没找到这个规律！！，而且这个公式后面也会用到）
        for(int i=0;i<row*col;i++){
            //旧矩阵的行和列
            oldrow = i/col;
            oldcol = i% col;
            //新矩阵的行和列
            newrow = i/c;
            newcol = i% c;
            res[newrow][newcol] = mat[oldrow][oldcol];
        }
        return res;

    }
};

3. 找出数组中最长的连续 1

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int temp = 0, sum=0;
        for(int i=0;i<nums.size();i++){
            if(nums[i]==1){
                sum++;
            }
            else{    //遇到0就计算此时其前面连续1的个数，并更新最长的连续
                temp = temp>sum? temp:sum;
                sum=0;
            }
        }
       temp = temp>sum? temp:sum;
        return temp;
    }
};

4. 搜索二维矩阵 II

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int row = matrix.size();
        int col = matrix[0].size();
        for(int i=0;i<row;i++){ //一行一行使用二分查找或者一列一列
            if(matrix[i][0]> target || matrix[i][col-1]<target) continue; //先排除不可能出现的行或者列
            if(binarySearch(matrix[i],target)) return true;
        }
        return false;
       
    }
    //二分查找的代码，直接锁死！！！ 由此可延伸出计算有序数组中重复元素的左边界和右边界
    bool binarySearch(vector<int> &nums, int target){
        int left=0,right=nums.size()-1; 
        while(left<=right){   //这里是相等
            int mid = left+ (right-left)/2;  //求中间元素的index用这种方法避免出错
            if(nums[mid]==target) return true;
            else if(nums[mid]>target){
                right=mid-1;
            }
            else{
                left = mid+1;
            }
        }
        return false;
    }
};

5. 有序矩阵的 Kth Element

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
    //求前k小的元素用大顶堆；求前k大的元素用小顶堆
        priority_queue<int > q;  //默认是大根堆
        int row = matrix.size();
        int col = matrix[0].size();
         for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
               q.push(matrix[i][j]);
               if(q.size()>k){   //简洁的代码：先一股脑把元素塞进大根堆里，再维持其长度保持在k
                   q.pop();
               }
               
            }
        }
        return q.top();
    }
};

6. 错误的集合

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        vector<int> res(2,0);
        int k= 0;
        for(int i=1;i<=nums.size();i++){
            int m = count(nums.begin(),nums.end(),i); //直接计算元素出现的次数，如果提前找到则返回，否则会超时
            if(m==0){
                k++;
                res[1]=i;
            }
            if(m==2){
                k++;
                res[0]=i;
            }
            if(k==2){
                break;
            }
        }
        
        return res;
    }
};

7. 数组的度

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        // 定义统计哈希表和最大频数
        unordered_map<int, int> mp;
        int max_fre = 0;
        // 边统计元素的频数，边记录最大频数
        for(int i = 0; i < nums.size(); i ++) {
            mp[nums[i]] ++;
            max_fre = max(max_fre, mp[nums[i]]);
        } 
        // 重构map
        mp.erase(mp.begin(), mp.end());
        // 利用滑动窗口，找到满足频数的最短长度
        int ans = nums.size();
        int left = 0, right = 0;
        while(right < nums.size()) {
            mp[nums[right]] ++;
            // 频数达到要求后，收缩左边界
            while(mp[nums[right]] == max_fre) {
                ans = min(ans, right - left + 1);
                mp[nums[left ++]] --;
            }
            right ++;
        }
        return ans;
    }
};

8. 嵌套数组

这道题有点拼智商，没有看到问题的本质：求所有环的最大长度。一旦出现在这个环里面，以后就不会出现

class Solution {
public:
    int arrayNesting(vector<int>& nums) {
        int res = 0;
        for(int i=0;i<nums.size();i++){
            int val = nums[i];
            if(val==-1) continue;  //已经被安排在之前的某一个环中
            nums[i]=-1;
            int size = 1;
            while(val!=i){  //如果没有出现环
                size++;
                int temp  = val;
                val = nums[val];
                nums[temp]=-1;
            }
            res = max(res,size);
        }
        return res;
    }
};

9. 分隔数组

这道题我的思路和优秀题解一致:只需要维护右边界即可，但是写出来的代码不够优雅

class Solution {
public:
    int maxChunksToSorted(vector<int>& arr) {
        int len = arr.size();
        int res = 0;
        int i=0;
        int m = 0;
        while(i<len){
            m = max(m,arr[i]);
            if(i==m){
                res++;
            }
            i++;
      
        }
        return res;

    }
};