力扣 217. 存在重复元素 --- C语言求解

题目描述：

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

题目链接

题解：

如果暴力遍历的方法会超出时间限制，官方给出两种求解。分别是使用哈希表和排序求解。

方法1. 使用哈希表

思路：首先定义一个哈希表。遍历数组 ，每读取一个元素判断哈希表中是否有该元素，没有则将该元素插入哈希表，有则说明之前插入过相同元素，返回true。遍历完数组仍然没有返回true，说明数组中的数组没有相同值，返回false.

C语言哈希表使用方法：

哈希表在头文件"uthash.h"中，只需要简单学习一下定义和函数的使用。

哈希结构体定义

#include "uthash.h"
struct hash
{
    int key;
    int value;
    UT_hash_handle hh;
};
struct hash* h = NULL;

其中UT_hash_handle是头文件"uthash.h"中定义的，,并且变量名必须为hh；Hash结构体是自定义的。key的类型可以是int, char *, char[]，void* 这4种，key值必须保存，因为添加节点时必须传入该参数名。value可以是任意类型，也可以没有value。

函数解释

添加 --------- 将定义好的哈希表s添加到h哈希表中，key是上面定义的键值，如果定义的是其他变量名，则要修改。

HASH_ADD_INT(h, key, s);

查找 ---------- 查找变量num是否在哈希表中，如果存在则返回其地址，不存在则返回空。此函数的变量参数是地址。

HASH_FIND_INT(hash, &num s);

删除 ---------- 删除hash中的s

HASH_DEL(hash, s);

计数 ----------- 返回元素总数

HASH_COUNT(hash);

 下面是哈希表法求解代码

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

方法二. 先排序再比较

排序算法官方使用的C语言自带的快排函数qsort，解读一下qsort参数

使用方法：qsort(nums, numsSize, sizeof(int), cmp);

nums：首元素地址

numsSize: 元素个数

sizeof(int): 元素大小

cmp: 元素比较方法，此方法需要定义，定义时需要严格遵守参数类型的设定，其返回结果一定要是整型。

int cmp (const void* e1, const void* e2);

如果是char大小比较，则用下面定义

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

  下面是排序法求解代码

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

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

自己手撕了一下快排结果会超出时间控制.........

快排原理：将最左边的元素设为中间值，比它大的放右边，小的放左边。然后再依次对左右两边的元素进行上面操作。

void quickSort(int *nums, int start, int end)
{
    int flag = nums[start];
    int temp = 0;
    int l = start;
    int r = end;
    while(l<r)
    {
        while(l<r && nums[r]>=flag)
        {
            r--;
        }
        while(l<r && nums[l]<=flag)
        {
            l++;
            
        }
        if(l<r)
        {temp = nums[l]; nums[l] = nums[r]; nums[r] = temp; }
    }
    nums[start] = nums[l];
    nums[l] = flag;
    quickSort(nums, start, l-1);
    quickSort(nums, l+1, end);

}