图解算法——两数之和

1. 题目描述

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

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

你可以按任意顺序返回答案。

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

2.示例

示例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]

3、题目要求:

  • 2 <= nums.length <= 104
  • -109 <= nums[i] <= 109
  • -109 <= target <= 109
  • 只会存在一个有效答案

进阶:你可以想出一个时间复杂度小于 O(n2) 的算法吗?

 

4、题目解析

该题是比较简单的。

  • 思路一是暴力破解法,即嵌套循环:

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

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

但是这样的话,复杂度就是O(n^2)了。基本任务算是完成,但是进阶是不行的。

代码如下:

思路一解法:

class Solution {
    public int[] twoSum(int[] nums, int target) {
    
        /*01暴力解法*/
        for(int i = 0; i<nums.length; i++){
            for(int j = i+1; j<nums.length; j++){
                if(nums[i]+nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[0];
    }
}
  • 思路二是降低复杂度:

从上述思路可发现,复杂度主要耗费在第二次遍历上了,如果第二次查询能够快一点,复杂度也就小了。

于是我们可以想到,复杂度小的,而且还是和查询有关的,本然想到hashmap或者hashtable的数据结构了,是的没错就是利用哈希表来存储值和索引。

具体思路是:先遍历数组将所有值存入一个hashmap中,考虑到两数之和,所以target的一半(target/2)在nums数组中可能会有两个,对于这种情况,是不能直接存储到map中的,因为会发生hash冲突,造成覆盖。所以在遍历过程中当遇到当前遍历到的值的大小是 target/2 值(nums[i] == target/2),且map中已经存有该值(map.containsKey(nums[i]))时,表示数组中有两个相同的数之和为target(如:3+3=6),否则就将该值和对应的索引存储到map中。

存储完成后,再一次遍历数组,求是否有两数之和为target的两个数(此时这两个数不相等,因为相等的在上一步会找到)。

但是,还有一种情况是什么?

就是数组中只有一个target/2 大小的值,这样就成不了和。所以在第二次遍历的时候,需要先移除当前值,然后再判断map中是否含有target - nums[i] 大小的值,如果有则返回索引数组。否则遍历完还没有就返回空数组。

代码如下:

        Map<Integer,Integer> map = new HashMap<>();
        int half = target/2;
        for(int i = 0; i<nums.length; i++){
            if(nums[i] ==half && map.containsKey(half)){
                return new int[]{map.get(half),i};
            }
            map.put(nums[i],i);
        }
        for(int i = 0; i<nums.length; i++){
            int k = nums[i];
            int v = map.get(nums[i]);
            //map.remove(k);
            if(map.containsKey(target - k)){
                return new int[]{i,map.get(target - k)};
            }
            //map.put(k,v);
        }
        
        return new int[0];
  • 思路三:第一遍遍历存储前map直接判断:

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

代码如下:

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

 

5、附录

最后附上我的leetcode的提交记录,真是几日不做题,手生的不行。

 

 

 

Over......

---------------

posted @ 2021-07-07 23:28  额是无名小卒儿  阅读(625)  评论(0编辑  收藏  举报