【Leetcode刷题】——Integer Array - 整型数组

1.【LeetCode448】：448. 找到所有数组中消失的数字

题目分析： 1-n之间有重复的，有没出现的，有出现一次。使用hashmap，空间复杂度为O(n)

方法一：哈希表，但是空间复杂度超过了O（n）

思想：

1. 可以用hashmap存储数据，建立映射。
2. 从1-n去遍历，看hashmap中有没有出现元素。
3. 有出现，下一个继续遍历，没有传入数组。

方法二： 使用数组本身，这样空间就不会多用

思想：

1. 已知元素的范围是1-n，数组下标的范围是0-n-1。从头开始遍历，比如说4，把它转换为对应的下标就是3，把3下标对应的元素变为负数（或者加n）,这样就相当于 标记 与下标3对应的数。
2. 如果某个数我们已经处理过了，这时候就要还原，然后再比较。
3. 最后再遍历一次，找出没出现过的下标。

示例：

	|
	4 3 2 7 8 2 3 1 
	0 1 2 3 4 5 6 7
遍历：4-1=3，把下标为3的元素前填负号->-7
     3-1=2，把下标为2的元素前填负号->-2
     遍历一遍后，数组变为
     -4 -3 -2 -7 8 2 -3 -1
     所以4和5这对应数字没有出现过，就是5和6没有出现过

题解：

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        int n=nums.size();
        for(int num:nums){
            int x=(num-1)%n;//对n取模还原它本来的值
            nums[x]+=n;//对这个元素加n
        }
        vector<int> ans;
        for(int i=0;i<n;i++){
            if(nums[i]<=n){
                ans.push_back(i+1);
            }
        } 
        return ans; 
    }
};

2【LeetCode48】：48. Rotate Image (Medium)

题目分析：要进行原地计算。1.寻找规律 2.按顺序进行旋转操作，避免覆盖原始值。

可以将旋转过程简化为两个翻转操作：

先按照主对角线进行翻转，再左右翻转

题解：

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

3 【LeetCode240】：240. Search a 2D Matrix II (Medium)

题目分析：在矩阵中不是边界的点有四个方向，所以我们要从某个边界开始，将四个方向转换为两个方向。这道题从右上或者左下都可以。

题解：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m=matrix.size();//行
        int n=matrix[0].size();//列
        if(m==0)    return false;
        // int i=0,j=n-1;//从右上开始搜索
        // while(i<m&&j>=0){
        //     if(matrix[i][j]==target){
        //         return true;
        //     }else if(matrix[i][j]>target){
        //         --j;
        //     }else{
        //         ++i;
        //     }    
        // }

        int i=m-1,j=0;//从左下开始搜索
        while(i>=0&&j<n){
            if(matrix[i][j]==target){
                return true;
            }else if(matrix[i][j]>target){
                --i;
            }else{
                ++j;
            }    
        }
        return false;
    }
};

4 【LeetCode769】：769. Max Chunks To Make Sorted (Medium)

题目分析：因为数组元素的特性，它的元素大小范围是0-n-1（并且不重复），刚好与数组下标对应。

从左往右遍历，同时记录当前的最大值，每当 当前最大值 等于数组位置时，我们可以多一次分割。

为什么可以通过这个算法解决问题呢？

1.如果当前最大值大于数组位置，则说明右边一定有小于数组位置的数字，需要把它也加入待排序的子数组；

2.又因为数组只包含不重复的0 到n，所以当前最大值一定不会小于数组位置。

3.所以每当当前最大值等于数组位置时，说明 当前最大值 之前的值都已经出现过了，可以进行一次划分，对后续划分没有影响。我们可以成功完成一次分割。

题解：

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