[LeetCode] 217.存在重复元素（Easy）C语言题解

最新推荐文章于 2022-11-20 22:09:14 发布

messi围巾一

最新推荐文章于 2022-11-20 22:09:14 发布

阅读量1.4k

点赞数 3

分类专栏： LeetCode-C LeetCode-C 文章标签：哈希表排序

本文链接：https://blog.csdn.net/qq_41979043/article/details/88687302

版权

LeetCode-C 同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

LeetCode-C

25 篇文章 3 订阅

订阅专栏

题目

给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 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

说明

①数据范围(自测)

-2147483648 ~ 2147483647

②相关话题

哈希表
数组
排序

③相似题目

④题目地址

解题方法

①暴力解法

两层 for 循环暴力判断。
时间复杂度：O(N^2)。
空间复杂度：O(1)。

②哈希表

虽然这道题的数据范围很大，但是经过测试可知：每组数据值的波动幅度并不大。所以可先求出数组元素的最大值和最小值，确定数据范围，然后用数组模拟的哈希表求解。
我们需要用哈希表记录数组中遍历过的元素，判断每个元素在它之前是否出现过，若出现过则返回 true，若没有则记录元素后继续判断。
用数组模拟的哈希表求解虽然直观，但是会浪费一些内存空间，所以更好的方法是使用 uthash。
uthash 是一个用 C 语言编写的开源库，使用宏实现了哈希表的增删改查等功能。
时间复杂度：O(N)。
空间复杂度：O(N)。

③排序

先使用快排函数排序数组，再判断数组中是否存在相邻两数相等，若存在则返回 true。
时间复杂度：O(Nlogn)。
空间复杂度：O(1)。

代码详解

暴力解法

bool containsDuplicate(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        for (int j = i+1; j < numsSize; j++) {
            if (nums[i] == nums[j])
                return true;
        }
    }
    
    return false;
}

哈希表

bool containsDuplicate(int* nums, int numsSize) {
    if (numsSize == 0)
        return false;
    
    int min = nums[0], max = nums[0], len;

    // 确定哈希表范围。
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > max)
            max = nums[i];
        if (nums[i] < min)
            min = nums[i];
    }
    
    // 哈希表。
    len = max-min+1;
    int* hash = malloc(sizeof(int)*len);
    
    // 初始化哈希表。
    for (int i = 0; i < len; i++)
        hash[i] = 0;
    for (int i = 0; i < numsSize; i++) {
        // 判断元素是否已经出现过。
        if (hash[nums[i]-min] == 1)
            return true;
        
        hash[nums[i]-min] = 1;
    }
    
    return false;
}

uthash

bool containsDuplicate(int* nums, int numsSize) {
    struct hash {
        int value;
        // makes this structure hashable.
        UT_hash_handle hh; 
    };
    
    struct hash *hashTable = NULL;
    
    for (int i = 0; i < numsSize; i++) {
        struct hash *h;
        // 查找值。
        HASH_FIND_INT(hashTable, nums+i, h);
        
        if (h)
            return true;
        else {
            h = malloc(sizeof(struct hash));
            h->value = nums[i];
            // 若值不存在则添加。
            HASH_ADD_INT(hashTable, value, h);
        }
    }
    
    return false;
}

排序

// 快排函数(升序)。
int compare(const void* a, const void* b) {
    return (*(int*)a)-(*(int*)b);
}

bool containsDuplicate(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] == nums[i-1])
            return true;
    }
    
    return false;
}