Leetcode第一题：两数之和

Posted 2023-04-29

参考技术A 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target的那两个整数，并返回它们的数组下标。
题目要求：
（1）你可以假设每种输入只会对应一个答案。
（2）数组中同一个元素在答案里不能重复出现。
（3）你可以按任意顺序返回答案。
题目实例：

通过遍历数组下标寻找满足条件的数组元素，并且两个数组元素的下标不能相等，否则为同一个元素，第一个元素直接遍历整个数组，第二个元素从第一个元素的下一位开始遍历，可减少时间复杂度。

leetcode会直接用测试用例进行测试，因此不用调用函数。

增加了输入数组和目标值的步骤，对函数进行调用。

查找时最好不要直接遍历元素，可以选择遍历元素下标，不然容易造成遍历出的两个值都是同一个下标的元素。

《LeetCode之每日一题》:273.两数之和

两数之和

• 有关题目
• • 题解

题目链接： 两数之和

有关题目

给定一个整数数组 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 <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

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

题解

法一：暴力法

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


int* twoSum(int* nums, int numsSize, int target, int* returnSize)
    int i, j;
    for (i = 0; i < numsSize; i++)
    
        for (j = i + 1; j < numsSize; j++)
        
            if (nums[i] + nums[j] == target)
            
                int *res = malloc(sizeof(int) * 2);
                res[0] = i, res[1] = j;
                *returnSize = 2;
                return res;
            
        
    

    *returnSize = 0;
    return NULL;

法二：哈希表
参考官方题解

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

struct hashTable 
    int key;
    int value;
    UT_hash_handle hh;
;

struct hashTable *hashtable;//哈希表

struct hashTable* find(int ikey)

    struct hashTable *temp;
    HASH_FIND_INT(hashtable, &ikey, temp);//在哈希表中寻找ikey，得到的地址存在temp中
    return temp;



void insert(int key, int value)

    struct hashTable *temp = find(key);

    if (NULL == temp)
    
        struct hashTable *it = (struct hashTable *)malloc(sizeof(struct hashTable));
        it->key = key, it->value = value;
        HASH_ADD_INT(hashtable, key, it);
    
    else 
    
        temp->value = value;//注意找到key的位置，返回的为指针，通过指针改变的值，会覆盖原值。
    



int* twoSum(int* nums, int numsSize, int target, int* returnSize)
    int i;
    hashtable = NULL;//哈希表
    for (i = 0; i < numsSize; i++)
    
        struct hashTable* it = find(target - nums[i]);

        if (NULL != it)
        
            int *ret = malloc(sizeof(int) * 2);
            ret[0] = it->value, ret[1] = i;
            *returnSize = 2;
            return ret;
        

        insert(nums[i], i);//录入键值
    

    *returnSize = 0;
    return NULL;