[LeetCode] 1.两数之和（Easy）C语言题解

题目

• 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
• 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

---

示例

①示例1

• 给定 nums = [2, 7, 11, 15], target = 9
• 因为 nums[0] + nums[1] = 2 + 7 = 9, 所以返回 [0, 1]

---

说明

①数据范围(自测)

• -2147483648 ~ 2147483647

②相关话题

• 哈希表
• 数组

③相似题目

• 15. 三数之和 — 力扣网
• 15. 3Sum — leetcode
• 18. 四数之和 — 力扣网
• 18. 4Sum — leetcode
• 167. 两数之和 II - 输入有序数组 — 力扣网
• 167. Two Sum II - Input array is sorted — leetcode

④题目地址

• 1. 两数之和 — 力扣网
• 1. Two Sum — leetcode

---

解题方法

①暴力解法

• 时间复杂度：O(N^2)。
• 空间复杂度：O(1)。

② 哈希表

• 虽然这道题的数组范围很大，但是经过测试可知：每组数据值的波动幅度有限，所以可先求出数组元素的最大值和最小值，确定数据范围，然后用数组模拟的哈希表求解(具体方法见代码)。
• 用数组模拟的哈希表求解虽然直观，但是会浪费一些内存空间，所以更好的方法是使用 uthash。
• uthash 是一个用 C 语言编写的开源库，使用宏实现了哈希表的增删改查等功能。
• 时间复杂度：O(N)。
• 空间复杂度：O(N)。

---

代码详解

• 暴力解法

int* twoSum(int* nums, int numsSize, int target) {
    int* result = (int*)malloc(sizeof(int)*2);

    for (int i = 0; i < numsSize-1; i++) {
        for (int j = i+1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
        
    return NULL;
}

• 两遍哈希表

int* twoSum(int* nums, int numsSize, int target) {   
    int* result = (int*)malloc(sizeof(int)*2);
    int min = INT_MAX, max = INT_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < min)
            min = nums[i];
        if (nums[i] > max)
            max = nums[i];
    }
    
    // 创建哈希表。
    int len = max-min+1;
    int* hash = malloc(sizeof(int)*len);
    
    // 初始化哈希表。
    for (int i = 0; i < len; i++)
        hash[i] = -1;
    // 迭代1 —— 将每个元素的值和它的索引添加到表中。
    for (int i = 0; i < numsSize; i++)
        hash[nums[i]-min] = i;
    // 迭代2 —— 检查每个元素所对应的目标元素(target - nums[i])是否存在于表中。
    for (int i = 0; i < numsSize; i++) {
        int diff = target-nums[i]-min;
        
        if (diff >= 0 && diff < len && hash[diff] >= 0 && i != hash[diff]) {
            result[0] = i;
            result[1] = hash[diff];
            return result;
        }
    }
    
    return NULL;
}

• 一遍哈希表

int* twoSum(int* nums, int numsSize, int target) {   
    int* result = (int*)malloc(sizeof(int)*2);
    int min = INT_MAX, max = INT_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < min)
            min = nums[i];
        if (nums[i] > max)
            max = nums[i];
    }
    
    // 创建哈希表。
    int len = max-min+1;
    int* hash = malloc(sizeof(int)*len);
    
    // 初始化哈希表。
    for (int i = 0; i < len; i++)
        hash[i] = -1;
    
    // 迭代1和迭代2一起进行，即边将每个元素的值和它的索引添加到表中，边检查每个元素所对应的目标元素(target-nums[i])是否存在于表中。
    for (int i = 0; i < numsSize; i++) {
        int diff = target-nums[i]-min;
        
        if (diff >= 0 && diff < len && hash[diff] >= 0 && i != hash[diff]) {
            result[0] = i;
            result[1] = hash[diff];
            return result;
        }
        else
            hash[nums[i]-min] = i;
    }
    
    return NULL;
}

• uthash

int* twoSum(int* nums, int numsSize, int target) {    
    struct hash {
        int key;
        int value;
        // makes this structure hashable.
        UT_hash_handle hh; 
    };
    
    struct hash *hashTable = NULL;
    int* result = malloc(sizeof(int)*2);
    
    for (int i = 0; i < numsSize; i++) {
        struct hash *h;
        // 查找键值对。
        HASH_FIND_INT(hashTable, nums+i, h);
        
        if (h) {
            result[0] = i;
            result[1] = h->value;
            return result;
        } 
        else {
            h = malloc(sizeof(struct hash));
            h->key = target-nums[i];
            h->value = i;
            // 添加键值对。
            HASH_ADD_INT(hashTable, key, h);
        }
    }
    
    return result;
}

---

附录

• 我的个人博客：messi1002.top
• 如有错误或疑惑之处 请联系 [email protected]
• 所有题目解答：fork me on github