每日一题——两数之和

最新推荐文章于 2025-04-06 22:32:11 发布
最新推荐文章于 2025-04-06 22:32:11 发布
阅读量731 收藏 25
点赞数 22
分类专栏： 算法题 C语言 面经 文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zxjiaya/article/details/145847778
版权

两数之和

问题描述

给定一个整数数组 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
  • 只会存在一个有效答案

思路分析

这个问题可以通过哈希表来高效地解决。具体思路如下：

  1. 创建一个哈希表，存储已经遍历过的数和它们对应的索引。
  2. 对于每个数，计算 target 减去当前数的差值，即 complement。
  3. 如果差值 complement 在哈希表中已经存在，则找到了符合条件的两个数，直接返回它们的下标。
  4. 如果差值不在哈希表中，则将当前数加入哈希表。

通过哈希表的查找特性，我们可以在一次遍历中完成求解，时间复杂度为 O(n)，空间复杂度为 O(n)。

代码实现

#include <stdio.h>
#include <stdlib.h>

typedef struct { 
    int* table; // 哈希表数组
    int size;   // 哈希表大小
} HashTable;

// 初始化哈希表
void initHash(HashTable* hashTable, int size) {
    hashTable->size = size;
    hashTable->table = (int*)malloc(size * sizeof(int));  // 分配内存
    for (int i = 0; i < size; i++) {
        hashTable->table[i] = -1;  // 初始化哈希表中的值为-1，表示没有存储任何数据
    }
}

// 释放哈希表内存
void freeHash(HashTable* hashTable) { 
    free(hashTable->table);  // 释放哈希表中的数组内存
    free(hashTable);  // 释放哈希表结构体内存
}

// 查找和为目标值的两个数的下标
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int size = 20001;  // 哈希表的大小，范围[-10^9, 10^9]需要加上10000进行偏移，保证索引为正
    HashTable* hashTable = (HashTable*)malloc(sizeof(HashTable)); // 分配哈希表结构体内存
    initHash(hashTable, size);  // 初始化哈希表

    for (int i = 0; i < numsSize; i++) {
        // 计算当前数的补数
        int complement = target - nums[i];
        int index = complement + 10000;  // 补数的哈希表索引，偏移+10000确保索引为正

        // 如果补数已经在哈希表中，说明找到了两个数，它们的和等于目标值
        if (hashTable->table[index] != -1) {
            int* result = (int*)malloc(2 * sizeof(int));  // 分配结果数组
            result[0] = i;  // 当前数的下标
            result[1] = hashTable->table[index];  // 补数的下标

            freeHash(hashTable);  // 释放哈希表内存
            *returnSize = 2;  // 设置返回结果的大小
            return result;  // 返回结果
        }

        // 如果补数不在哈希表中，将当前数添加到哈希表
        int numIndex = nums[i] + 10000;  // 当前数的哈希表索引
        hashTable->table[numIndex] = i;  // 将当前数的下标存入哈希表
    }

    freeHash(hashTable);  // 释放哈希表内存
    *returnSize = 0;  // 没有找到结果，返回0
    return NULL;  // 返回空值
}

代码解析

1. 哈希表结构体定义

我们定义了一个 HashTable 结构体，它包含两个成员：

  • table：一个数组，用于存储哈希表中的数据。我们使用一个整数数组，哈希表的大小为 20001，以适应数据范围 [-10^9, 10^9]，通过加上 10000 来保证索引为正。
  • size：哈希表的大小。

2. 初始化哈希表

在 initHash 函数中，我们为哈希表分配内存，并将哈希表中的所有值初始化为 -1，表示该位置还没有存储数据。

3. 释放哈希表内存

在 freeHash 函数中，我们释放了哈希表的内存，包括哈希表的数组和结构体本身。

4. 主函数 twoSum

  • 我们首先计算目标值 target 和当前数的差值 complement。
  • 通过偏移量 10000 将补数的范围映射到哈希表的索引范围内，确保索引为正。
  • 如果哈希表中已经存在补数，则返回当前数和补数的下标。
  • 如果哈希表中不存在补数，则将当前数及其下标存入哈希表。

5. 返回结果

  • 如果找到了符合条件的两个数，我们将它们的下标存入一个结果数组并返回。
  • 如果没有找到符合条件的数对，返回 NULL。

复杂度分析

  • 时间复杂度：O(n)，其中 n 是数组 nums 的长度。我们只需要遍历一次数组，每次操作的时间复杂度为 O(1)（哈希表查找和插入操作）。
  • 空间复杂度：O(n)，我们需要一个哈希表来存储最多 n 个元素。
    可惜，这种解法需要空间过大，无法满足所有案例。

第二种解法

// 定义哈希表的结构体
struct hashTable {
    int key;                  // 哈希表的键，用于存储数值
    int val;                  // 哈希表的值，用于存储索引
    UT_hash_handle hh;        // UT_hash库提供的宏，用于处理哈希表操作
};

// 声明一个全局指针，用于指向哈希表的头节点
struct hashTable* hashtable;

// 查找哈希表中是否存在某个键
struct hashTable* find(int ikey) {
    struct hashTable* tmp;                        // 定义一个临时指针用于存储查找结果
    HASH_FIND_INT(hashtable, &ikey, tmp);         // 使用UT_hash库提供的宏查找键为ikey的元素
    return tmp;                                   // 返回查找结果
}

// 向哈希表中插入键值对
void insert(int ikey, int ival) {
    struct hashTable* it = find(ikey);            // 首先查找键是否已存在
    if (it == NULL) {                             // 如果键不存在
        struct hashTable* tmp = malloc(sizeof(struct hashTable)); // 分配内存
        tmp->key = ikey, tmp->val = ival;         // 初始化键值对
        HASH_ADD_INT(hashtable, key, tmp);        // 使用UT_hash库提供的宏将新元素添加到哈希表中
    } else {                                      // 如果键已存在
        it->val = ival;                           // 更新值
    }
}

// 解决“两数之和”问题
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable = NULL;                             // 初始化哈希表为空
    for (int i = 0; i < numsSize; i++) {          // 遍历数组
        struct hashTable* it = find(target - nums[i]); // 查找当前元素的补数是否在哈希表中
        if (it != NULL) {                         // 如果找到补数
            int* ret = malloc(sizeof(int) * 2);   // 分配内存用于存储结果
            ret[0] = it->val, ret[1] = i;         // 存储两个数的索引
            *returnSize = 2;                      // 设置返回结果的大小为2
            return ret;                           // 返回结果
        }
        insert(nums[i], i);                       // 将当前元素及其索引插入哈希表
    }
    *returnSize = 0;                              // 如果未找到结果，设置返回结果的大小为0
    return NULL;                                  // 返回NULL
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/two-sum/solutions/434597/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官方解法虽然看着复杂，实际上最重要的是多了#include “uthash.h”，自己得学会如何调库。

代码功能概述

这段代码使用了UTHash库来实现“两数之和”问题。目标是在给定数组中找到两个数，它们的和等于目标值 target，并返回这两个数的索引。

代码详细注释

1. 哈希表结构体定义
struct hashTable {
    int key;          // 键：存储数组中的数值
    int val;          // 值：存储数组中数值对应的索引
    UT_hash_handle hh; // UTHash宏定义的句柄，用于内部管理哈希表节点
};
  • key：哈希表的键，用于存储数组中的数值。
  • val：哈希表的值，用于存储数组中数值对应的索引。
  • UT_hash_handle hh：这是UTHash库要求的字段，用于管理哈希表的内部结构（例如，存储链表指针、哈希值等）。用户不需要直接操作这个字段。
2. 哈希表指针
struct hashTable* hashtable;
  • 这是一个全局变量，指向哈希表的根节点。UTHash库通过这个指针来管理整个哈希表。
3. 查找函数
struct hashTable* find(int ikey) {
    struct hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp); // 使用UTHash宏查找键为ikey的节点
    return tmp; // 返回找到的节点，如果未找到则返回NULL
}
  • HASH_FIND_INT：这是UTHash库提供的宏，用于在哈希表中查找键为 ikey 的节点。
    • 第一个参数是哈希表的根节点指针（hashtable）。
    • 第二个参数是指向键值的指针（&ikey）。注意，这里传入的是键值的地址。
    • 第三个参数是输出参数，用于存储查找结果。
  • 如果找到键为 ikey 的节点，则返回该节点；否则返回 NULL。
4. 插入函数
void insert(int ikey, int ival) {
    struct hashTable* it = find(ikey); // 先查找键是否已存在
    if (it == NULL) { // 如果键不存在
        struct hashTable* tmp = malloc(sizeof(struct hashTable)); // 分配新节点
        tmp->key = ikey, tmp->val = ival; // 初始化新节点的键和值
        HASH_ADD_INT(hashtable, key, tmp); // 使用UTHash宏将新节点插入哈希表
    } else { // 如果键已存在
        it->val = ival; // 更新节点的值
    }
}
  • HASH_ADD_INT：这是UTHash库提供的宏，用于将一个新节点插入哈希表。
    • 第一个参数是哈希表的根节点指针（hashtable）。
    • 第二个参数是哈希表结构体中用于哈希的字段名（key）。
    • 第三个参数是要插入的新节点（tmp）。
  • 如果键已存在，则更新该键对应的值。
5. 两数之和函数
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable = NULL; // 初始化哈希表为空
    for (int i = 0; i < numsSize; i++) {
        struct hashTable* it = find(target - nums[i]); // 查找补数是否已存在
        if (it != NULL) { // 如果找到补数
            int* ret = malloc(sizeof(int) * 2); // 分配返回数组
            ret[0] = it->val, ret[1] = i; // 返回补数的索引和当前索引
            *returnSize = 2; // 设置返回数组的大小
            return ret; // 返回结果
        }
        insert(nums[i], i); // 将当前数值及其索引插入哈希表
    }
    *returnSize = 0; // 如果未找到结果，返回大小为0
    return NULL; // 返回NULL
}
  • 逻辑流程：
    1. 初始化哈希表：将 hashtable 设置为 NULL，表示哈希表为空。
    2. 遍历数组：
      • 对于数组中的每个数字 nums[i]，计算它的补数（target - nums[i]）。
      • 使用 find 函数查找补数是否已经在哈希表中。
      • 如果找到补数：
        • 分配一个大小为2的数组 ret，存储补数的索引和当前索引。
        • 设置返回数组的大小为2。
        • 返回结果。
      • 如果未找到补数：
        • 调用 insert 函数，将当前数字及其索引插入哈希表。
    3. 未找到结果：
      • 如果遍历结束后仍未找到结果，设置返回大小为0，并返回 NULL。

6. 主函数（示例）

int main() {
    int nums[] = {2, 7, 11, 15}; // 输入数组
    int target = 9;              // 目标值
    int returnSize;              // 返回结果的大小
    int* result = twoSum(nums, 4, target, &returnSize); // 调用两数之和函数

    if (result) { // 如果找到结果
        printf("Result: [%d, %d]\n", result[0], result[1]); // 打印结果
        free(result); // 释放结果内存
    } else { // 如果未找到结果
        printf("No solution found.\n");
    }

    return 0;
}
  • 输出：
    Result: [0, 1]
  • 解释：
    • 数组 [2, 7, 11, 15] 中，nums[0] + nums[1] = 2 + 7 = 9，因此返回 [0, 1]。

总结

这段代码通过UTHash库实现了“两数之和”问题，具有以下优点：

  1. 动态哈希表：UTHash库可以动态管理哈希表，适合处理大范围的整数。
  2. 简洁高效：UTHash提供了简洁的宏来操作哈希表，代码易于理解和维护。
  3. 时间复杂度低：哈希表操作的时间复杂度为O(1)，整体算法时间复杂度为O(n)。
python算法每日一题——两数之和
Katherine0819的博客
05-10 1547
题目 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 示例 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 解答 // 两数之和 def twoSum(nums,target): n = len(nums) for i in range(n): for
每日一题——力扣——求两数之和
爱编程的晖哥的博客
01-09 822
力扣——求两束之和全网最详细的解法
每日一题——两数相加
zxjiaya的博客
03-12 1067
每日一题——两数相加
每日一题——判断素数
保护小周ღ的博客
07-09 2473
博主在这里分享三种方法： 第一种是比较常用的穷举法。 第二种使用sqrt()函数;取平方根，判断至平方根即可。 第三种我们观察发现，如果一个数不能被 [2,10],区间的数整除(注意自己不能被自己整除)，那么这个数，我们可以称之为素数。............
力扣每日一题——快乐数
weixin_43772611的博客
02-18 5401
文章目录前言一、示例二、代码 前言 题目：编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为： 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/happy-number ..
C语言每日一题——查找数字
2201_75324712的博客
01-12 1787
C语言查找数字
每日一题——两个数相加绝对值最小
MoJair的博客
10-28 1353
两个数相加绝对值最小，本题重点是要注意题目条件其和的的绝对值最小以及同一个元素不能使用两遍，因此使用了Math类的abs函数取绝对值，使用Set自带去重的特性来去掉可能存在的相同元素，从而满足同一个元素不能使用两遍的条件，之后采用了双重for循环列举所有配对求和，再通过三元运算得到最小值。
leetcode 每日一题——371. 两整数之和
m0_51566313的博客
11-09 303
给你两个整数 a 和 b ，不使用 运算符 + 和 - ​​​​​​​，计算并返回两整数之和。
每日一题——力扣——完美数
爱编程的晖哥的博客
01-21 1042
题目来源于力扣——507. 完美数 - 力扣（LeetCode） (leetcode-cn.com) 对于一个正整数，如果它和除了它自身以外的所有 正因子 之和相等，我们称它为 「完美数」。 给定一个整数n，如果是完美数，返回 true，否则返回 false 示例 1： 输入：num = 28 输出：true 解释：28 = 1 + 2 + 4 + 7 + 14 1, 2, 4, 7, 和 14 是 28 的所有正因子。 示例 2： 输入：num = 6 输出：true 示例 3...
LeetCode每日一题——猜数字游戏
qq_28810395的博客
11-09 6297
转载请注明作者和出处：https://blog.youkuaiyun.com/qq_28810395 运行平台： Windows 10 LeetCode官网：Fhttps://leetcode-cn.co 一、猜数字游戏   你在和朋友一起玩 猜数字（Bulls and Cows）游戏，该游戏规则如下：   写出一个秘密数字，并请朋友猜这个数字是多少。朋友每猜测一次，你就会给他一个包含下述信息的提示： 猜测数字中有多少位属于数字和确切位置都猜对了（称为 “Bulls”, 公牛）， 有多少位属于数字猜对了但是位置.
python每日一题——6三数之和
WY_记录
11-25 348
python每日一题——6三数之和
每日一题——力扣——统计位数为偶数的数字
爱编程的晖哥的博客
01-18 1024
题目来源于力扣——1295. 统计位数为偶数的数字 - 力扣（LeetCode） (leetcode-cn.com) 给你一个整数数组nums，请你返回其中位数为偶数的数字的个数。 示例 1： 输入：nums = [12,345,2,6,7896] 输出：2 解释： 12 是 2 位数字（位数为偶数） 345 是 3 位数字（位数为奇数） 2 是 1 位数字（位数为奇数） 6 是 1 位数字 位数为奇数） 7896 是 4 位数字（位数为偶数） 因此只有 12 和 789...
每日一题——力扣——将数字变成0的操作次数
爱编程的晖哥的博客
01-31 1905
题目来源于力扣——1342. 将数字变成 0 的操作次数 - 力扣（LeetCode） (leetcode-cn.com) 给你一个非负整数num，请你返回将它变成 0 所需要的步数。 如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。 示例 1： 输入：num = 14 输出：6 解释： 步骤 1) 14 是偶数，除以 2 得到 7 。 步骤 2） 7 是奇数，减 1 得到 6 。 步骤 3） 6 是偶数，除以 2 得到 3 。 步骤 4） 3 是奇数，减 1 得...
【LeetCode 热题100】 45. 跳跃游戏 II 的算法思路及python代码
pljnb的博客
04-03 628
给定一个长度为 n 的 0 索引整数数组nums。初始位置为nums[0]。每个元素nums[i]表示从索引 i 向后跳转的最大长度。换句话说，如果你在nums[i]处，你可以跳转到任意返回到达的最小跳跃次数。生成的测试用例可以到达。
选择排序笔记
ChenShan3的博客
04-03 323
基础版就是每次在未排序的数中选一个最小的放到左边已排序的末尾，而优化版的快速排序就是每次不仅把最小的放到左边，也把最大的放到右边，减少遍历次数，这里的实现要结合双指针。原始数组 [5₁, 2, 5₂, 1]（5₁ 和 5₂ 是值相同的两个元素）。第一轮选择最小元素 1，与 5₁ 交换 → [1, 2, 5₂, 5₁]。每次从未排序部分选择最小（或最大）元素，放到已排序部分的末尾。交换操作可能跨越多个位置，破坏相等元素的原始顺序。此时 5₂ 跑到了 5₁ 前面，相对顺序改变。最好/最坏/平均情况均为。
棋盘问题（DFS）
最新发布
m0_74995784的博客
04-06 785
在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放 kk 个棋子的所有可行的摆放方案数目 CC。
[dp_3 路径问题] 不同路径 | 障碍物 II | 珠宝的最高价值
一个人知道自己为什么而活，他就能够接收任何一种生活
04-03 1085
初始化 | 虚拟节点 | 想从dp表找回之前矩阵的位置所以下标都要统一-1才行。i-1，j-1。 依赖前两位,所以要初始两位 if(s[0]=='0') return 0; //这个是这个题目的特殊意思要领悟到 ● 动态规划就是一个从小往大的有逻辑性的计算 ● 以此来避免对相同的事情重复计算很多次 ● 因为填表之后，如果碰到已经计算过的数值就可以直接进行调用啦~
二叉树——队列bfs专题
xsc2004zyj的博客
04-06 375
我们之前遇到过二叉树的层序遍历，只需要用队列先进先出的特性就可以达到层序遍历的目的。而这里不是二叉树，也就是说让节点的孩子入队列时不仅仅是左右孩子了，而是它的所有孩子。而我们看这棵多叉树的构造，它的孩子是存储在数组中的。所以我们在让孩子入队时只需要依次让数组中的所有节点入队列即可。而这道题的要求是返回一个二维数组，数组的元素就是每一层的层序遍历结果。
深入解析力扣39.组合总和：回溯算法的妙用
2302_81116822的博客
04-01 565
给定一个无重复元素的数组candidates和一个目标值target，找出candidates中所有可以使数字和为target的组合。数组中的数字可以被重复使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

tt555555555555

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值