【LeetCode刷题】1. 两数之和
1. 两数之和
给定一个整数数组 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 <= 104-109 <= nums[i] <= 109-109 <= target <= 109- 只会存在一个有效答案
解法一：暴力匹配
代码
拿我曾学过的语言以刷题的形式复习一遍。
JS版
var twoSum = function(nums, target) {
//暴力
//外层循环从下标0遍历到倒数第2个数，因为还要考虑里程循环
var len=nums.length;
for(var i=0;i<len-1;i++){
//里层循环则是在每次外层循环下，i+1的后面循环一一匹配
for(var j=i+1;j<len;j++){
//采用严格相等
if(nums[i]+nums[j]===target){
return [i,j];
}
}
}
return [];
};
C++版
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int n=nums.size();
for(int i=0;i<n-1;++i){
for(int j=i+1;j<n;++j){
if(nums[i]+nums[j] == target){
return {i,j};
}
}
}
return {};
}
};
Java版
class Solution {
public int[] twoSum(int[] nums, int target) {
int n=nums.length;
for(int i=0;i<n-1;++i){
for(int j=i+1;j<n;++j){
if(nums[i]+nums[j] == target){
return new int[]{i,j};
}
}
}
//表示返回为空数组
return new int[0];
}
}
Python3版
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
n=len(nums)
for i in range(n-1):
for j in range(i+1,n):
if nums[i] + nums[j] == target:
return [i,j]
return []
Go语言版
func twoSum(nums []int, target int) []int {
for i := range nums {
for j := i+1; j<len(nums); j++ {
if nums[i]+nums[j] == target{
return []int {i,j}
}
}
}
return nil
}
解法二：
弄个哈希表，哈希表记录下每个数值中对应的下标index。
而在边遍历数组nums边把nums[index]和它对应的index加入到哈希表情况下，目标值target - nums[index] = 另一个需要的值another，接着判断这个another是否在哈希表中，并且没有碰到下标重复的情况，如果符合了就返回结果
如果发现不重复的another不在哈希表中，那么说明还应继续找下一个another，而这由下一个nums[index]决定能不能找到。
代码
JS版
var twoSum = function(nums, target) {
//创建哈希表,key值是nums里的数值，value值则是下标
let map = new Map();
//目标值 - 遍历nums值 = 需要的另一个整数，而且也可以做到最先出现的数为有效
for(let i=0;i<nums.length;i++){
let another = target - nums[i];
//如果another这个值在nums里，并且get到它的index不重复的话，就返回结果
if(map.has(another) && map.get(another) != i ){
return [map.get(another),i];
}
//如果发现当前nums[i]不在哈希表中，就加进去
map.set(nums[i],i);
}
//找了所有的情况但是都没结果
return [];
};
C++版
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
//使用无序哈希表,key是数值，value是下标
unordered_map<int,int> map;
for(int i=0;i<nums.size();++i){
//查找哈希表是否有应匹配到的另一个值
auto it = map.find(target-nums[i]);
//由于我使用的是无序哈希表，所以如果值index重复的话，一定放到最后的位置
if(it != map.end()){
return {it->second,i};
}
//如果发现nums[index]不再哈希表就加上
map[nums[i]]=i;
}
return {};
}
};
Java版
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int i=0;i<nums.length;++i){
//判断another是否在哈希表中，再就返回结果
//不用担心值重复后的下标也跟着重复的事情发生
if(map.containsKey(target-nums[i])){
return new int[]{map.get(target-nums[i]),i};
}
//如果nums[index]不在哈希表中
map.put(nums[i],i);
}
return new int[0];
}
}
Python3版
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
map={}
for i,num in enumerate(nums):
if target-num in map:
return [map[target-num],i]
map[nums[i]]=i
return []
Go语言版
func twoSum(nums []int, target int) []int {
hashtable := map[int]int{}
for i,x := range nums {
if another_index,ok := hashtable[target-x];ok {
fmt.Println(ok)//返回true
return []int{another_index,i}
}
hashtable[x]=i
}
return nil
}
参考
unordered_map::find_C ++标准库|WIKI教程
浙公网安备 33010602011771号