「前端刷题」217.存在重复元素（EASY）

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第16天，点击查看活动详情

题目(Contains Duplicate)

链接：https://leetcode-cn.com/problems/contains-duplicate
解决数：2961
通过率：55.7%
标签：数组 哈希表 排序 
相关公司：amazon adobe google 

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

 

示例 1：

输入： nums = [1,2,3,1]
输出： true

示例 2：

输入： nums = [1,2,3,4]
输出： false

示例 3：

输入： nums = [1,1,1,3,3,4,3,2,4,2]
输出： true

 

提示：

• 1 <= nums.length <= 105
• -109 <= nums[i] <= 109

思路

数组存在重复元素，首先我们可以将数组排序，然后再遍历判断，但是这样的复杂度是 $NlogN$，但是，我一般会选择牺牲空间保时间，所以这里我将使用哈希表来解决这道题，让时间复杂度为 $N$。

流程如下：

1. 创建一个哈希表，然后从左往右遍历数组。
2. 检测哈希表中是否已存在当前字符，若存在，直接返回结果，若不存在，将当前字符加入哈希表，供后续判断使用即可。

代码

var containsDuplicate = function(nums) {
    let map = new Map();
    for(let i of nums){
        if(map.has(i)){
            return true;
        }else{
            map.set(i, 1);
        }
    }
    return false;
};

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

struct hashTable {
    int key;
    UT_hash_handle hh;
};

bool containsDuplicate(int* nums, int numsSize) {
    struct hashTable* set = NULL;
    for (int i = 0; i < numsSize; i++) {
        struct hashTable* tmp;
        HASH_FIND_INT(set, nums + i, tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct hashTable));
            tmp->key = nums[i];
            HASH_ADD_INT(set, key, tmp);
        } else {
            return true;
        }
    }
    return false;
}

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set set = new HashSet();
        for (int x : nums) {
            if (!set.add(x)) {
                return true;
            }
        }
        return false;
    }
}

func containsDuplicate(nums []int) bool {
    set := map[int]struct{}{}
    for _, v := range nums {
        if _, has := set[v]; has {
            return true
        }
        set[v] = struct{}{}
    }
    return false
}

思路2

• 思路：先排序，然后循环数组，判断相邻元素是否相同
• 复杂度：时间复杂度O(nlogn)，空间复杂度O(logn)，排序需要的栈空间

代码

var containsDuplicate = function(nums) {
    nums.sort((a, b) => a - b);//排序
    const n = nums.length;
    for (let i = 0; i < n - 1; i++) {
        if (nums[i] === nums[i + 1]) {//判断相邻元素是否相同
            return true;
        }
    }
    return false;
};