【每日力扣4】存在重复元素

一、题目

给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例 1:

输入: [1,2,3,1]
输出: true

示例 2: 

输入: [1,2,3,4]
输出: false

示例 3:

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

二、思路

受上一期的启发，先考虑了只有一个元素的退化情况，写在前面。

遍历数组中的每个元素nums[i]，将之与它前面所有元素（nums[0,i)）全部比对，如果存在与之相同的元素，则立即返回true，反之则继续向下遍历

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        int n = nums.size();
        if(n < 2) return false;//排除只有一个元素的退化情况
        for(int i = 1; i < n;i++)//对于每个元素num[i]，
            for(int j = 0; j<i;j++)//与它前面所有元素num[0,i)
                if(nums[i] == nums[j])//进行比对，如果相同
                    return true;//则返回真值
        return false;//否则，说明数组中不存在相同元素
    }
};

但是时间复杂度为O（N²），超出时间限制。

于是乎想到了新的方法——哈希表散列

这里用散列函数hash(x) = x mod n，这里x为nums[]中的每一个元素nums[i]，n为数组的长度。解决散列冲突时使用的冲突解决方法为开放定址法中的线性探测法。一开始创建哈希表时将数列初始化为0，因此对于数列中的元素0（如果存在的话）需要特殊讨论。

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        int n = nums.size();
        if(n < 2) return false;//排除只有一个元素的退化情况
        int* hash = new int[n];//创建一个长度与数组nums相等长度的哈希表hash[]，使用的散列函数为hash(x) = x mod nums.size()
        for(int i = 0; i<n; i++)
            hash[i] = 0;//先把哈希表中所有元素初始化为0
        bool has0 = false;//对于值为0的元素需要特殊讨论，因为初始时hash[]中的元素都默认为0
        for(int i = 0; i < n; i++)
            {
                if(nums[i]==0)//讨论nums[i]为0的特殊情况
                    {
                        if(has0) return true;
                        has0 = true;
                    }
                else
                {
                    int hashNum = nums[i] % n;
                    if(hashNum<0) hashNum += n;//这里额外考虑当nums[i]为负值的情况
                    bool pushed = false;
                    while(!pushed)
                    {   
                        if(hash[hashNum]==0)//如果该值nums[i]没有被放入散列表相应位置中（即先前未出现相同值）
                            {
                                hash[hashNum] = nums[i];//那就把它存入散列表中
                                pushed = true;
                            }
                        else//否则，散列表的hashNum位置已经放入了数字
                        {
                            if(hash[hashNum] == nums[i])//要么那个数字和nums[i]相等（即存在重复元素）
                                return true;
                            else
                                {
                                    hashNum++;//要么发生了散列冲突，这里使用开放定址法中的线性探测法，逐一往后找空位
                                    hashNum %= n;//防止溢出
                                }
                        }
                    }
                }
            }
            return false;
    }
};

通过了！但是结果不是让人那么满意qwq，现在来看看官方答案吧！

三、官方解法

方法一：排序

在对数字从小到大排序之后，数组的重复元素一定出现在相邻位置中。因此，我们可以扫描已排序的数组，每次判断相邻的两个元素是否相等，如果相等则说明存在重复的元素。

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/contains-duplicate/solution/cun-zai-zhong-fu-yuan-su-by-leetcode-sol-iedd/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：O(NlogN)，其中 N 为数组的长度。需要对数组进行排序。
• 空间复杂度：O(logN)，其中 N 为数组的长度。注意我们在这里应当考虑递归调用栈的深度。

方法二：哈希表

对于数组中每个元素，我们将它插入到哈希表中。如果插入一个元素时发现该元素已经存在于哈希表中，则说明存在重复的元素。

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> s;
        for (int x: nums) {
            if (s.find(x) != s.end()) {
                return true;
            }
            s.insert(x);
        }
        return false;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/contains-duplicate/solution/cun-zai-zhong-fu-yuan-su-by-leetcode-sol-iedd/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：O(N)，其中 N为数组的长度。
• 空间复杂度：O(N)，其中 N为数组的长度。

四、学习心得

1.哈希表会利用到数组中的元素值的特点来决定存入的位置。例如本题需要判断数组中是否存在某个值出现多次，那么出现多次的那个值便会在哈希表的同一位置出现多次（解决冲突前），那么本题便可以根据这个信息来得出“数组存在重复值”。

2.双指针法适用于有序数组，对于day1的《删除排序数组中的重复项》，由于题目里的数组是排好序的，那么在这里用双指针法可以避免二次循环带来的O（N²）时间复杂度，降为O（N）。但是对于本题，给出的数组不是排好序的，不能直接使用双指针。但是可以先将数组进行排序，然后再利用指针（由于本题只是简单地要求判断有没有重复元素，不需要更多的操作，因此不需要双指针）来处理。那么这里的时间复杂度便为O(NlogN) + O(N) = O(NlogN)。