LeetCode#442. 数组中重复的数据 & LeetCode#448. 找到所有数组中消失的数字 & LeetCode#41. 缺失的第一个正数 & 剑指offer#3-1 & #3-2

# 题目：给定一个整数数组 a，其中1 ≤ a[i] ≤ n （n为数组长度）, 其中有些元素出现两次而其他元素出现一次。

找到所有出现两次的元素。

你可以不用到任何额外空间并在O(n)时间复杂度内解决这个问题吗？

示例：

输入:
[4,3,2,7,8,2,3,1]

输出:
[2,3]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-all-duplicates-in-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法一：哈希表

  #include<map>
    class Solution {
    public:
        vector<int> findDuplicates(vector<int>& nums) {
            auto n = nums.size();
            vector<int> ret;
            map<int,int> m;    
            
            for(auto i=0;i<n;i++){
                if(m.find(nums[i])!=m.end()){
                    ret.push_back(nums[i]); 
                }else{
                    m[nums[i]] = 1;
                }
            }
            return ret;
            
    };

复杂度分析：

1. 时间复杂度：O(n)
2. 空间复杂度：O(n)

解法二：先把数放到对应位置上，然后遍历不在位置上的数

分析：利用桶排序的思想，每个数要存放到对应的桶上，最后遍历一次看哪些不在对应的桶上，则这些数就是重复的数。

for(int i=0;i<n;i++){
            while(nums[i]!=nums[nums[i]-1]){
                auto temp = nums[i];
                nums[i] = nums[temp-1];
                nums[temp-1] = temp;
            }
        }
    for(int i=0;i<n;i++){
        if(nums[i]!=i+1){
            ret.push_back(nums[i]);
        }
    }

复杂度分析：

1. 时间复杂度：O(n)
2. 空间复杂度：O(1)

题目#3-1:找出数组中任意一个重复的数

解法一:哈希表

解法二:也是类似桶排序,公车上人坐错位置后更换位置(但是只适用于查找出任意一个重复的数的时候才可以,如果要找出多个,就不适用了)

分析:遍历所有的数:
1.如果该数m等于下标i,说明这个数在对应的位置上,那么我们跳过该数
2.其他不在对应位置上的数会有两种情况:
1.要么该数是在其对应位置上已经有了正确的数,那么就说明这个数是重复的
2.要么该数在对应位置上被其他数占用了,因此我们把自己交换至正确位置

void duplication(vector<int>& vec,vector<int>& dup){
//类似于巴士车上的人位置都坐错了，通过一个一个交换位置来遍历n个人，因此时间复杂度是O（n）
//判断是否重合的过程是这样的，每次交换完必定会得到一个我这个位置上应该有的数，如果得不到，
//说明应该是有重合的数在原来的位置上了，因此寻找重复的时候其实就是看别的位置上的数跟自己应该
//在的位置上的数是否重合。
//    for(size_t i=0;i<vec.size();){
//        if(vec[i] == i) i++;//如果是在它应该在的位置上我们就跳过它
//        else if(vec[i] == vec[vec[i]]) {//如果不在的话，就要比较我这是因为原来位置有重复数字还是没有
//            dup.push_back(vec[i]);//如果有重复数字说明我这个数重复了，没办法回到原来位置
//            i++;
//        }
//        else{//如果没有重复数字，那我就回到原来位置上去
//            auto temp = vec[i];
//            vec[i] = vec[vec[i]];
//            vec[temp] = temp;
//        }
//    }
    for(int i=0;i<vec.size();i++){
        while(vec[i]!=i){
            if(vec[i] == vec[vec[i]]){
                dup.push_back(vec[i]);
                break;
            }
            auto temp = vec[i];
            vec[i] = vec[vec[i]];
            vec[temp] = temp;

        }
    }
}

复杂度分析:

1. 时间复杂度:O(n)
2. 空间复杂度:O(1)

题目:给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。

找到所有在 [1, n] 范围之间没有出现在数组中的数字。

您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。

示例:

输入:
[4,3,2,7,8,2,3,1]

输出:
[5,6]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法:利用类似解法,先把每个数放到正确位置上,然后找出那些下标不等于正确数的下标.

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        vector<int> ret;
        //先把每个数都放置到对应的位置上
        for(int i=0;i<nums.size();i++){
            while(nums[i]!=nums[nums[i]-1]){
                auto temp = nums[i];
                nums[i] = nums[temp-1];
                nums[temp-1] = temp;
            }
        }
        // for(auto c:nums){
        //     cout<<c<<" ";
        // }
        cout<<endl;
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=i+1){
                ret.push_back(i+1);
            }
        }
        return ret;
    }
};

复杂度分析:

1. 时间复杂度:O(n)
2. 空间复杂度:O(1)

题目:缺失的第一个正数

给定一个未排序的整数数组，找出其中没有出现的最小的正整数。

示例 1:

输入: [1,2,0]
输出: 3
示例 2:

输入: [3,4,-1,1]
输出: 2
示例 3:

输入: [7,8,9,11,12]
输出: 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-missing-positive
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法:还是桶排序思想

分析:思路是:对于1<=x<=size()的数,我们将他们存放到对应的x-1的位置上
然后遍历排序后的数组,从0开始如果遍历到不符合它位置上的数,那么这个数就是所求
如果整个数组都符合,那么就返回size()+1
注意这里不要从0开始存放,不然会出现其他问题

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        //思路是:对于1<=x<=size()的数,我们将他们存放到对应的x-1的位置上
        //然后遍历排序后的数组,从0开始如果遍历到不符合它位置上的数,那么这个数就是所求
        //如果整个数组都符合,那么就返回size()+1
        //注意这里不要从0开始存放,不然会出现其他问题
        for(int i=0;i<nums.size();i++){
            while(nums[i]>0 && nums[i]<=nums.size() && nums[i]!=nums[nums[i]-1] ){
                auto temp = nums[i];
                nums[i] = nums[nums[i]-1];
                nums[temp-1] = temp;
            }
        }
        // for(auto c:nums)
        //     cout<<c<<" ";
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=i+1)
                return i+1;
        }
        return nums.size()+1;
    }
};

复杂度分析:

1. 时间复杂度:O(n)
2. 空间复杂度:O(1)

题目#3-2:不修改数组找出任意一个重复的数字

解法一:哈希法

分析:设置一个数组,然后遍历原数组将各个数存放到对应位置上,如果存放过程出现存放相同数,则返回.

int getDuplication1(const int* numbers,int length){
    //类似于哈希方法
    int* arr = (int*)malloc((length+1)*sizeof(int));
    for(auto i=0;i<length;i++){
        if(arr[numbers[i]]==numbers[i]){
            return numbers[i];
        }else{
            arr[numbers[i]] = numbers[i];
        }
    }
    return -1;
}

复杂度分析:

1. 时间复杂度:O(n)
2. 空间复杂度:O(n)

解法二:按值二分查找+统计个数

分析:按照值从start到end,计算中间值middle,统计数组中处于start-middle的数的个数,如果数的个数大于middle-start+1,说明在这个值区间内有重复数字,进而将end设置为middle,类似于二分查找,但是在这里是按照值的范围,以及统计个数来进行查找,而不是根据下标范围,注意区分!但是这个算法不能保证找出所有重复的数字,当出现两个2时候,会有扫描到1-2中的数等于2的情况,会跳过两个2的判断.

int statistic(const int* numbers,int length,int start,int end){
    int count = 0;
    for(auto i = 0;i < length;i++){
        if(numbers[i]>=start && numbers[i]<=end){
            count++;
        }
    }
    return count;
}
int getDuplication2(const int* numbers,int length){
    //利用查找值的二分法+统计
    int start = 1,end = length;
    while(start<=end){
        int middle = start + (end - start) / 2;
        auto count = statistic(numbers,length,start,middle);
        if(start==end){
            if(count>1)return start;
            else return -1;
        }
        if(count>(middle-start)+1){//要么是大于
            end = middle;
        }else{//要么是等于
            start = middle + 1;
        }
    }
    return -1;
}

复杂度分析:

1. 时间复杂度;按值二分查找,设执行m次,有2^m=n,因此可以得到m为O(logn),但统计过程是O(n),因此是O(nlogn);
2. 空间复杂度:O(1).

**