letcode 1.两数之和（官方题解笔记）

最新推荐文章于 2024-05-08 22:01:18 发布

zll_@

最新推荐文章于 2024-05-08 22:01:18 发布

阅读量393

点赞数

分类专栏： letcode 学习笔记文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_45662289/article/details/129585718

版权

letcode 学习笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

题目描述

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

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

1.暴力枚举

1.1思路

时间复杂度：O(n²)
空间复杂度：O(1)

枚举数组中的每一个数 x，寻找数组中是否存在 target - x。

当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。
而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。

1.2代码

1.C

// 整数数组：nums，整数数组大小：numsSize，整数目标值：target，返回答案数组大小：returnSize
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    for (int i = 0; i < numsSize; ++i) {	// i 遍历 nums 寻找 x
        for (int j = i + 1; j < numsSize; ++j) {	// j 遍历数组寻找 target - x
            if (nums[i] + nums[j] == target) {	// 找到 x，target - x
            	// 为答案数组开辟两个空间
                int* ret = malloc(sizeof(int) * 2);
                // 答案数组分别存放 x 的下标和 target - x 的下标
                ret[0] = i, ret[1] = j;
                *returnSize = 2;	// 答案数组大小为 2
                return ret;	// 返回答案数组
            }
        }
    }
    // 没有找到 x 和 target - x 的情况
    *returnSize = 0;	// 答案数组大小置 0
    return NULL;	// 返回 NULL
}

2.C++

class Solution {
public:
	// 整数数组：nums，整数目标值：target
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();	// 整数数组大小
        for (int i = 0; i < n; ++i) {	// i 遍历 nums 寻找 x
            for (int j = i + 1; j < n; ++j) {	// j 遍历 nums 寻找 target - x
                if (nums[i] + nums[j] == target) {	// 找到 x，target - x
                    return {i, j};	// 返回 x，target - x 下标
                }
            }
        }
        return {};	// 未找到，返回空值
    }
};

3.Python3

class Solution:
	# 函数格式解释，Python3可以对函数参数和返回值进行类型指定和类型检查
	# nums: List[int]，指定整数数组 nums，类型为 int 型 List
	# target: int，指定整数目标值 target，类型为 int
	# -> List[int]，指定函数返回值类型为 int 型 List
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)	# 整数数组大小
        for i in range(n):	# i 遍历 nums 寻找 x
            for j in range(i + 1, n):	# j 遍历 nums 寻找 target - x
                if nums[i] + nums[j] == target:	# 找到 x，target - x
                    return [i, j]	# 返回 x，target - x 数组下标
        
        return []	# 未找到，返回空值

3.Java

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int n = nums.length;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }
}

4.Golang

func twoSum(nums []int, target int) []int {
    for i, x := range nums {
        for j := i + 1; j < len(nums); j++ {
            if x+nums[j] == target {
                return []int{i, j}
            }
        }
    }
    return nil
}

2.哈希表

2.1思路

时间复杂度：O(n)
空间复杂度：O(1)

暴力枚举时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。

使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(n) 降到 O(1)。

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

2.2代码

1.C

// 定义哈希表结构体
struct hashTable {
    int key;	// 值
    int val;	// 值对应在数组中的下标
    // 此步骤不可省略，变量可以不进行初始化，用于声明此结构体为哈希表
    UT_hash_handle hh;
};

struct hashTable* hashtable;	// 定义哈希指针，指向前面的 hashTable 数据结构

// 查找 hashtable 中是否已经存在 key
struct hashTable* find(int ikey) {	// 通过 key 值来查找
    struct hashTable* tmp;	// 定义指向 hashTable 的指针变量 tmp
    // [参数解读] hashtable：哈希表，&ikey：key 的地址，tmp：输出 key 的结构 
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;	// 返回 key 的结构，若 key 不存在则返回 NULL
}

// 哈希表中不存在 key 为 target - x 的结点时才会执行此函数
void insert(int ikey, int ival) {
	// 查找 hashtable 中是否已经存在目标 key：x
    struct hashTable* it = find(ikey);
    if (it == NULL) {	// 若不存在目标 key：x，将 x ，x 对应的下标 i 作为键值对插入 hashtable
    	// 为结点申请内存空间
        struct hashTable* tmp = malloc(sizeof(struct hashTable));
        // 将 x，x 对应的下标 i 存到 tmp 中，ikey：x，val：i
        tmp->key = ikey, tmp->val = ival;
        // [参数解读] hashtable：哈希表，key：键字段名称，tmp：指向要添加的结构的指针
        HASH_ADD_INT(hashtable, key, tmp);
    } else {	// 若存在目标 key：x
        it->val = ival;	// 将 x 对应的下标 i 插入 key：x 对应的 val
    }
}

// 整数数组 nums，整数目标值：target
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable = NULL;	// hashtable 指针初始为空
    for (int i = 0; i < numsSize; i++) {	// i 遍历 nums
    	// 寻找 key 为 target - x 对应的哈希结点
        struct hashTable* it = find(target - nums[i]);
        if (it != NULL) {	// 找到了，直接返回 x 和 target - x 数组下标
            int* ret = malloc(sizeof(int) * 2);	// 为答案数组开辟两个空间
            ret[0] = it->val, ret[1] = i;	// 答案数组分别存放 target - x，x 的下标
            *returnSize = 2;	// 答案数组的大小为 2
            return ret;	// 返回答案数组
        }
        // 未找到，将 x，i 作为新的键值对插入哈希表
        insert(nums[i], i);
    }
    // 没有找到 x，target - x 的情况
    *returnSize = 0;	// 答案数组大小置 0
    return NULL;	// 返回 NULL
}

2.C++

class Solution {
public:
	// 整数数组：nums，整数目标值：target
    vector<int> twoSum(vector<int>& nums, int target) {
    	// 用 unordered_map 容器创建哈希表，键：int，值：int，变量名：hashtable
        unordered_map<int, int> hashtable;	// [哈希表结构] key：值，val：值对应在数组里的下标
        for (int i = 0; i < nums.size(); ++i) {
        	// auto 的作用：根据后面变量的值推测变量的类型，此处等价于 unordered_map<int, int> it = hashtable.find(target - nums[i]);
            auto it = hashtable.find(target - nums[i]);
            // unordered_map::end() 返回一个迭代器，指向 unordered_map 容器中最后一个元素的位置
            if (it != hashtable.end()) {	// 若哈希表中存在 key 为 target - x 的键值对
                return {it->second, i};	// 返回 target - x，x 的下标
            }
            // 不存在，则将键值对 key：x，val：i 插入哈希表
            hashtable[nums[i]] = i;
        }
        // 没有找到 x，target - x 的情况
        return {};
    }
};

3.Python3

class Solution:
	// 整数数组：nums，整数目标值：target
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()	# Python 中的字典类型相当于哈希表
        for i, num in enumerate(nums):	# i 遍历 nums
            if target - num in hashtable:	# 字典里存在 key：target - x
                return [hashtable[target - num], i]	# 返回 target - x，x 的下标
            # 字典里不存在 key：target - x，将键值对 key：nums[i]，value：i 写入字典
            hashtable[nums[i]] = i	
        # 未找到 x，target - x 则返回空值
        return []

4.Java

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

5.Golang

func twoSum(nums []int, target int) []int {
    hashTable := map[int]int{}
    for i, x := range nums {
        if p, ok := hashTable[target-x]; ok {
            return []int{p, i}
        }
        hashTable[x] = i
    }
    return nil
}