第3题——找出数组中重复的数字

题目：
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3

// 核心代码模式
class Solution {
/*
方法一：哈希表    才想到一个问题就是 unordered_map 初始化的时候默认是0啊~傻~
时间复杂度 O(n) ： 遍历数组使用 O(n) ，HashSet 添加与查找元素皆为 O(1) 。
空间复杂度 O(n) ： 遍历数组使用 O(n)

补充：sort 函数的时间复杂度为 O(n*log2n)，因此不要用先排序再邻位比较的方法了

方法二：原地排序
时间复杂度 O(n) ： 
空间复杂度 O(1) ：
以示例来进行分析，nums数组长度为7，那么数字的范围是 [0,6] 闭区间，刚好对应的下标范围也是 [0, 6]
从头开始遍历，将每一个元素归位到与下标相等的位置上。
注意这个方法要用 while 循环来进行遍历，因为下标是跳来跳去的昂~
// 如果相等，就继续下一个下标的判断，如果不相等，交换元素之后，仍然对本下标位置的值进行判断
*/

public:
    // // 方法一：哈希表
    // int findRepeatNumber(vector<int>& nums) {
    //     // 构造一个空的unordered_map对象，不包含任何元素，大小为0。
    //     unordered_map<int, int> arr;
    //     for(int i = 0; i < nums.size(); ++i)
    //     {
    //         arr[nums[i]]++;
    //         if(arr[nums[i]] > 1)
    //         {
    //             return nums[i];
    //         }
    //     }
    //     return -1;
    // }

    // 方法二：原地交换
    // 因为长度为n，数字在 0-n-1范围内，所以可以考虑，注意不能用 for 循环遍历
    int findRepeatNumber(vector<int>& nums)
    {  
        int i = 0;
        while(i < nums.size())
        {
            // 如果相等，就继续下一个下标的判断，如果不相等，交换元素之后，仍然对本下标位置的值进行判断
            if(i == nums[i])
            {
                ++i;
                continue;
            }
            else
            {
                if(nums[nums[i]] == nums[i])
                {
                    return nums[i];
                }
                else
                {
                    // swap(nums[i], nums[nums[i]]);
                    // 注意刚刚在这里翻了个错误，不能先把 temp = nums[i]，这样会连带后面也改变了。
                    int temp = nums[nums[i]];
                    nums[nums[i]] = nums[i];
                    nums[i] = temp;
                }
            }
        }
        return -1;
    }
};

// ACM模式下代码
#include<iostream>
#include<vector>
#include<unordered_map>
using namespace std;


class Solution {
public:
    ////第一种：时间复杂度为O(N*N)，空间复杂度为O(n)   在线编译还不通过，哼哼哼唧 
    ////编译不通过是因为函数定义的返回值类型为int ,我却定义了一个返回值类型为指针的，
    ////该通之后，运行超时了                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
    int findRepeatNumber(vector<int>& nums)
    {
        int num =0;
        int *pnum=NULL;
        for (int i = 0; i < nums.size() - 1; ++i)
        {
            for (int j = i + 1; j < nums.size(); ++j)
            {
                if (nums[i] == nums[j])
                {
                    pnum = &nums[i];
                    
                }
            }
        }
        num=*pnum;
        return num;
    }

    //第二种：哈希表（unordered_map容器）时间复杂度为O(n)，空间复杂度为O（n）
    // 一般降低时间复杂度的方法就是，通过空间换时间，就是例如哈希表或者集合，把遍历过的值记录下来，这样就可以节约大量的时间
    int findRepeatNumber(vector<int>& nums)
    {
        unordered_map<int, int> map;
        for (auto it : nums)
        {
            ++map[it];  //课本第385页详解 map容器中key对应的值执行++操作
            if (map[it] > 1)
            {
                return it;
            }
        }
        return -1;
        //  return -1; 表示返回一个代数值，一般用在子函数结尾。按照程序开发的一般惯例，表示该函数失败；
        //  return  0; 一般用在主函数结束时，按照程序开发的一般惯例，表示成功完成本函数。
    }

    //第三种：原地交换
    /*
       因为数值的范围是 0~n-1 因此数组元素的索引与值之间是一对多的关系，因此可以建立索引和值的映射关系。
       遍历中，第一次遇到数字 xx 时，将其交换至索引 xx 处；而当第二次遇到数字 xx 时，一定有 nums[x] = xnums[x]=x ，此时即可得到一组重复数字。

       原地交换感觉很牛，但是有点难以理解呀~
		
		点睛：这里比较的是三个数字：
		i        nums[i]      nums[nums[i]]

    */

    int findRepeatNumber(vector<int>& nums)
    {
        int i = 0;
        while (i < nums.size())
        {
            //如果nums[i]==i，就说明已经下标和数字匹配，就向下面寻找不匹配的值
            if (i == nums[i])
            {
                ++i;
                continue;
            }

            //检测是否发生碰撞，碰撞就说明两者有重复的数字，
            //直接返回重复数字，如果没有碰撞，就把该数字放到其应该放置的位置
            if (nums[i] == nums[nums[i]])
            {
                return nums[i];
            }
            else
            {
                swap(nums[i], nums[nums[i]]);
            }
        }
        return -1;
    }    
};

int main()
{
    vector<int> nums{ 2, 3, 1, 0, 2, 5 };
    
    Solution s1;
    int a=s1.findRepeatNumber(nums);

    cout << a;
}