题目：两数之和题目
目录
方法一：暴力枚举
C
/*
定义解决两数相加问题的函数，返回类型为整型，其中：
nums：整型一维动态空间
numsSize：整型，表示动态空间的长度
target：整型
returnSize：整型一维动态空间，表示返回的动态空间长度
*/
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
// 两个for循环寻找动态空间中全部数字的相加情况
for (int i = 0; i < numsSize; ++i) { // 从0到（numsSize-1）循环
for (int j = i + 1; j < numsSize; ++j) { // 从（i+1）到（numsSize-1）循环
if (nums[i] + nums[j] == target) { // 判断索引i和j对应的动态空间中的数字相加是否等于target
int* ret = malloc(sizeof(int) * 2); // 定义整型一维容器ret，并限制为 2*sizeof(int)=8 个字节的空间
ret[0] = i, ret[1] = j; // 将索引i、索引j赋值到容器ret
*returnSize = 2; // 表示返回的动态空间大小为2
return ret; // 返回容器ret
}
}
}
*returnSize = 0; // 重置动态空间长度
return NULL; // 返回空，清除缓存
}
C++
class Solution { // 定义类“Solution”
public: // 公有继承
/*
定义整型函数“twoSum”，返回类型为整型，其中：
nums：整型调用容器
target：整型
*/
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size(); // 取nums容器的长度并赋值给n
// 两个for循环寻找容器中全部数字的相加情况
for (int i = 0; i < n; ++i) { // 从0到（n-1）循环
for (int j = i + 1; j < n; ++j) { // 从（i+1）到（n-1）循环
if (nums[i] + nums[j] == target) { // 判断索引i和j对应的容器nums中的数字相加是否等于target
return {i, j}; // 满足条件，则返回索引i和j组成的数组
}
}
}
return {}; // 返回空数组，清除缓存
}
};
go
/*
定义解决两数相加问题的函数"twoSum"，返回类型为整型动态空间,其中：
nums：整型一维动态空间
target：整型
*/
func twoSum(nums []int, target int) []int {
// 两个for循环寻找容器中全部数字的相加情况
for i, x := range nums { // i从0到（nums的长度-1）循环，其中x为i索引对应的值
for j := i + 1; j < len(nums); j++ { // 从（i+1）到（nums的长度）循环
if x+nums[j] == target { // 判断 x 与 j对应的容器nums中的数字 相加是否等于target
return []int{i, j} // 满足条件，则返回索引i和j组成的数组
}
}
}
return nil // 返回空，清除缓存
}
java
// 定义类“Solution”
class Solution {
/*
定义函数“twoSum”，返回类型为整型数组，其中：
nums：整型调用容器
target：整型
*/
public int[] twoSum(int[] nums, int target) {
int n = nums.length; // 取nums容器的长度并赋值给n
// 两个for循环寻找容器中全部数字的相加情况
for (int i = 0; i < n; ++i) { // 从0到（n-1）循环
for (int j = i + 1; j < n; ++j) { // 从（i+1）到（n-1）循环
if (nums[i] + nums[j] == target) { // 判断索引i和j对应的容器nums中的数字相加是否等于target
return new int[]{i, j}; // 满足条件，则返回索引i和j组成的数组
}
}
}
return new int[0]; // 返回空数组，清除缓存
}
}
python
# 定义类“Solution”
class Solution:
'''
定义解决两数相加问题的函数,其中：
self：表示实例本身，类中定义函数的第一参数
nums：整型列表
target：整型
函数的返回类型：整型列表
'''
def twoSum(self,nums: List[int], target: int) -> List[int]:
n = len(nums) # 取nums列表的长度并赋值给n
# 两个for循环寻找列表中全部数字的相加情况
for i in range(n): # 从0到（n-1）循环
for j in range(i + 1, n): # 从（i+1）到（n-1）循环
if nums[i] + nums[j] == target: # 判断i和j索引对应的列表中的数字相加是否等于target
return [i, j] # 满足条件则返回索引i和j构成的列表
return [] # 返回空列表，清除缓存
方法二：哈希表
C
struct hashTable { // 声明结构体hashTable
int key; // 定义整型键
int val; // 定义整型值
UT_hash_handle hh; // 创建hashTable
};
struct hashTable* hashtable;
// 寻找符合条件的索引
struct hashTable* find(int ikey) {
struct hashTable* tmp;
HASH_FIND_INT(hashtable, &ikey, tmp);
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);
} else {
it->val = ival;
}
}
/*
定义解决两数相加问题的函数，返回类型为整型，其中：
nums：整型一维动态空间
numsSize：整型，表示动态空间的长度
target：整型
returnSize：整型一维动态空间，表示返回的动态空间长度
*/
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
hashtable = NULL; // 初始化哈希表
for (int i = 0; i < numsSize; i++) { // 从0到（numsSize-1）循环
struct hashTable* it = find(target - nums[i]);
if (it != NULL) { // 若寻找结果不为空
int* ret = malloc(sizeof(int) * 2); // 定义整型一维容器ret，并限制为 2*sizeof(int)=8 个字节的空间
ret[0] = it->val, ret[1] = i;
*returnSize = 2; // 表示返回的动态空间大小为2
return ret; // 返回容器ret
}
insert(nums[i], i); // 将索引存入
}
*returnSize = 0; // 重置动态空间长度
return NULL; // 返回空，清除缓存
}
C++
class Solution { // 定义类“Solution”
public: // 公有继承
/*
定义整型函数“twoSum”，返回类型为整型，其中：
nums：整型调用容器
target：整型
*/
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> hashtable; // 创建无序表hashtable，键和值都为整型
for (int i = 0; i < nums.size(); ++i) { // 从0到（nums长度-1）循环
auto it = hashtable.find(target - nums[i]); // 寻找 hashtable 中是否存在指定的 key 对应的映射关系：target = nums[i] + nums[i]
if (it != hashtable.end()) { // 如果 hashtable 没有被遍历完
return {it->second, i}; // 则返回索引
}
hashtable[nums[i]] = i; // 输出符合条件的索引
}
return {}; // 返回空，清除缓存
}
};
go：
/*
定义解决两数相加问题的函数"twoSum"，返回类型为整型动态空间,其中：
nums：整型一维动态空间
target：整型
*/
func twoSum(nums []int, target int) []int {
// Go 语言Map(集合)：https://www.runoob.com/go/go-map.html
hashTable := map[int]int{} // 建立无序的键值对的集合hashTable，键和值都为整型
for i, x := range nums { // 枚举数列 nums ，i为索引，x为对应值
if p, ok := hashTable[target-x]; ok { // 判断 hashtable 中是否存在指定的 key 对应的映射关系：target = x + x
return []int{p, i} // 返回符合条件的索引
}
hashTable[x] = i // 输出符合条件的索引
}
return nil // 返回空，清除缓存
}
java
// 定义类“Solution”
class Solution {
/*
定义函数“twoSum”，返回类型为整型数组，其中：
nums：整型调用容器
target：整型
*/
public int[] twoSum(int[] nums, int target) {
// java的HashMap：https://www.runoob.com/java/java-hashmap.html
Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>(); // 创建 HashMap 对象 hashtable，键和值都为整型
for (int i = 0; i < nums.length; ++i) { // 从0到（nums长度-1）循环
// Java HashMap containsKey() 方法：https://www.runoob.com/java/java-hashmap-containskey.html
if (hashtable.containsKey(target - nums[i])) { // 检查 hashtable 中是否存在指定的 key 对应的映射关系：target = nums[i] + nums[i]
return new int[]{hashtable.get(target - nums[i]), i}; // 将存在的键值对中的i放入hashtable容器
}
hashtable.put(nums[i], i); // 输出hashtable容器
}
return new int[0]; // 返回空数组，清除缓存
}
}
python
# 定义类“Solution”
class Solution:
'''
定义解决两数相加问题的函数,其中：
self：表示实例本身，类中定义函数的第一参数
nums：整型列表
target：整型
函数的返回类型：整型列表
'''
def twoSum(self, nums: List[int], target: int) -> List[int]:
hashtable = dict() # 创建字典hashtable，即键值对
# Python3 enumerate() 函数：https://www.runoob.com/python3/python3-func-enumerate.html
for i, num in enumerate(nums): # 枚举数列 nums ，i为索引，num为对应值
if target - num in hashtable: # 判断 hashtable 中是否存在指定的 key 对应的映射关系：target = num + num
return [hashtable[target - num], i] # 返回存在的键值对应的i值
hashtable[nums[i]] = i # 输出符合条件的索引
return [] # 返回空列表，清除缓存
扫一扫
3629
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
