力扣 两数之和 C语言 题解_力扣第一题两数之和c语言

力扣 两数之和 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(n^2) 的算法吗？

二、具体思路

• 首先，我们肯定是想到了二层循环暴力的解法，时间复杂度为 O(n^2) ，很显然是不太好的，作为算法练习，肯定要选择更优的做法
• 因此，我们选择哈希表的做法，借助 “uthash.h” 库中的函数对哈希表进行操作
• 我们只需要判断 target - nums[i] 是否在哈希表中即可
• 如果不在记录下位置，如果在直接输出 nums[i] 和 target - nums[i] 的位置即可

三、知识储备

1.哈希表的定义

#include "uthash.h"

struct my_struct {
    int id;            /* we'll use this field as the key */
    char name[10];
    UT_hash_handle hh; /* makes this structure hashable */
};

struct my_struct *g_users = NULL;
1
2
3
4
5
6
7
8
9

2.哈希表的查找

struct my_struct *find_user(int user_id)
{
    struct my_struct *s = NULL;
    HASH_FIND_INT(g_users, &user_id, s);
    return s;
}
1
2
3
4
5
6

3.哈希表的插入

void add_user(struct my_struct *s) 
{
    HASH_ADD_INT(g_users, id, s );
}
1
2
3
4

四、编写代码

1.哈希表的定义

typedef struct Hash * PtrH;
struct Hash {
    int val;
    int key;
    UT_hash_handle hh;
};
PtrH hash;
1
2
3
4
5
6
7

2.哈希表的查找

PtrH find(int key)
{
    PtrH temp;
    HASH_FIND_INT(hash, &key, temp);
    return temp;
}
1
2
3
4
5
6

3.哈希表的插入

void insert(int key, int val)
{
    PtrH judge = find(key);
    if (judge == NULL)
    {
        PtrH temp = (PtrH *) malloc(sizeof(struct Hash));
        temp->key = key;
        temp->val = val;
        HASH_ADD_INT(hash, key, temp);
    }
    else {
        judge->val = val;
    } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.完整代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
typedef struct Hash * PtrH;
struct Hash {
    int val;
    int key;
    UT_hash_handle hh;
};
PtrH hash;

PtrH find(int key)
{
    PtrH temp;
    HASH_FIND_INT(hash, &key, temp);
    return temp;
}

void insert(int key, int val)
{
    PtrH judge = find(key);
    if (judge == NULL)
    {
        PtrH temp = (PtrH *) malloc(sizeof(struct Hash));
        temp->key = key;
        temp->val = val;
        HASH_ADD_INT(hash, key, temp);
    }
    else {
        judge->val = val;
    } 
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int * results = NULL;//The returned array
    hash = NULL;//hashTable
    PtrH temp;
    int i;//loop var

    for (i = 0; i < numsSize; i++)
    {
        temp = find(target - nums[i]);
        if (temp != NULL)
        {
            results = (int *) malloc(sizeof(int)*2);
            results[0] = i;
            results[1] = temp->val;
            * returnSize = 2;
            return results;
        }
        insert(nums[i], i);
    }

    * returnSize = 0;
    return results;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

---

五、测评结果

六、总结评价

这是力扣题库中的第一道题，本来用暴力也是可以求出来的，但是很显然这不是我们做题的目的，我们的目标应该是更快，更省，更优，因此，哈希表是很不错的选择，将时间复杂度降到了 O(n) ，大家可以继续思考下：怎么样可以让内存的消耗更小？

有问题欢迎各位大佬指出
力扣系列将持续更新，欢迎关注，一起学习