力扣 存在重复元素 C语言实现

原题地址

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/24/

题目描述

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

如果任意一值在数组中出现至少两次，函数返回 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

1. 暴力解法

最简单的方法，直接对每个元素遍历整个数组，判断是否存在相同元素，代码如下：

/* Traverse the entire array for each element 
 * to find if there is duplicate. */
bool
containsDuplicate_v(int* nums, int numsSize){
    int i, j;
    
    if (numsSize <= 1)
        return false;
    
    for (i = 0; i < numsSize; i++)
    {
        for (j = i + 1; j < numsSize; j++)
        {
            if (nums[i] == nums[j])
                return true;
        }
    }
    return false;
}

时间复杂度计算方法如下：
对于一个下标为i的元素，需要向后查找n - i个元素判断其是否存在重复者，因此总的操作数量为：$$(n-1)+(n-2)+(n-3)+...+2+1=\sum _{i=1}^{n}i=\frac{n(n+1)}{n}$$
因此，时间复杂度为$O(n^2)$。

2. 排序解法

想到是整数数组，所以可以先将数组进行排序，那么如果存在相同的元素，一定是紧挨着的。
那么将数组先进行排序，在逐个判断当前元素是否与其后继元素是否相等即可。代码如下：

int cmp(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}

/* Sort the arrya first, and then determine for each element whethre its 
 * successor is the same */
bool
containsDuplicate_s(int *nums, int numsSize)
{
    int i;

    qsort(nums, numsSize, sizeof(int), cmp);

    for (i = 0; i < numsSize - 1; i++)
    {
        if (nums[i] == nums[i + 1])
            return true;
    }
    return false;
}

时间复杂度计算过程如下：
C语言中的qsort()函数采用的是快速排序，因此，其时间复杂度为$O(nlogn)$。而后一部分的遍历时间复杂度为$n$。所以整个算法的时间复杂度为$O(nlogn)$

哈希表

判断元素是否重复，这很容易就联想到了哈希表。直接将数组遍历一遍，对于某个元素，如果哈希表中已经存在，则表示重复，返回true。如果不存在，标记为存在即可。
这里需要注意：

1. 给的数组中可能有负数，所以要根据最大值和最小值一起来设置哈希表的大小。
2. 要将数组中的数向哈希表中进行映射
   代码如下：

/* Use hash table to find duplicate value. */
bool
containsDuplicate_h(int *nums, int numsSize)
{
    int i, min, max;

    if (numsSize <= 1)
        return false;

    /* Min value and max value will decide the size of hash table. */
    min = max = nums[0];
    for (i = 1; i < numsSize; i++)
    {
        min = (nums[i] < min ? nums[i] : min);
        max = (nums[i] > max ? nums[i] : max);
    }

    /* Initial the hash table. */
    int table_size = max - min + 1;
    int hash_table[table_size];
    for (i = 0; i < max - min; i++)
        hash_table[i] = 0;

    /* Fill in the hash table and determin
     * if there are duplicate values. */
    int hash_val;
    for (i = 0; i < numsSize; i++)
    {
        hash_val = nums[i] - min;
        if (hash_table[hash_val] == 1)
            return true;
        hash_table[hash_val] = 1;
    }

    return false;

算法时间复杂度为一次遍历的时间，$O(n)$。
算法空间复杂度为数组最大值与最小值的差值，无法确定。