每日一题（c语言）

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

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

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 104

• -109 <= nums[i] <= 109

• -109 <= target <= 109

• 只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

思路

暴力法，利用两个for循环找出两个数加起来为target,输出数组下标即可

c语言用哈希表的方法相对复杂，偷一下櫴了。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   for(int i=0;i<numsSize-1;i++) {
       for(int j=i+1;j<numsSize;j++){
           if(nums[i]+nums[j]==target){
             int *ret=malloc(sizeof(int)*2);
             ret[0]=i,ret[1]=j;
             *returnSize=2;
             return ret;
           }
       }
   }
   return NULL;
}

2.哈希表(大佬的解法）

创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

//定义结构体
typedef struct hash_table{
    int key;
    int val;
    UT_hash_handle hh;
}hash_table_t;
hash_table_t *hash_table;

//查询
hash_table_t* search(int key)
{
    hash_table_t *find;
    HASH_FIND_INT(hash_table,&key,find);
    return find;
}

//插入
void insert(int key,int val)
{
    hash_table_t *find = search(key);
    if(find == NULL)
    {
        hash_table_t *temp = malloc(sizeof(hash_table_t));
        temp->key = key;
        temp->val = val;
        //以键值对的形式存储，所以要把temp作为一个整体传进去
        HASH_ADD_INT(hash_table,key,temp);
    }
    else
    {
        find->val = val;
    }
}

//删除
void delete(int key)
{
    hash_table_t *find = search(key);
    if(find != NULL)
    {
        HASH_DEL(hash_table,find);
        free(find);
        find = NULL;
    }
}

void delete_all()
{
    hash_table_t *current,*temp;
    HASH_ITER(hh,hash_table,current,temp){
        HASH_DEL(hash_table,current);
        free(current);
        current = NULL;
    }
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hash_table = NULL;
    for(int i = 0; i < numsSize; i++)
    {
        hash_table_t *find = search(target - nums[i]);
        if(find != NULL)
        {
            int *ret = malloc(2*sizeof(int));
            ret[0] = i;
            ret[1] = find->val;
            *returnSize = 2;
            return ret;
        }
        //把数组中的元素全部插入到hash表中
        insert(nums[i],i);
    }
    *returnSize = 0;
    return NULL;
}