实战Java算法系列一：细品就懂的两数之和【珍藏系列】

最新推荐文章于 2022-05-18 08:56:56 发布

一颗剽悍的种子

最新推荐文章于 2022-05-18 08:56:56 发布

阅读量224

点赞数 3

分类专栏：《Java算法系列》文章标签：算法 java leetcode

本文链接：https://blog.csdn.net/A_hxy/article/details/113414181

版权

《Java算法系列》专栏收录该内容

2 篇文章 0 订阅

订阅专栏

获得过图灵奖的Pascal之父提出过一个著名的公式 “数据结构+算法=程序”，据说因为这个公式而让他获得图灵奖。

在《实战Java算法系列》开始前得说说，这里的题都是可以在LeetCode（中文名：力扣）这个网站中练习。

LeetCode（中文名：力扣）
https://leetcode-cn.com

除了可以练习带答案都给你，并且有视频和文字的解答。

但是我发现很多人即使对着答案，也看了文字视频或各种图解也没有看懂，还是一头雾水。

我总结究其原因有三个：

1. 对语法本身还不够理解。
2. 没有理顺代码逻辑。
4. 没有理解核心代码块。（即使看了之后码不出原因）

而《实战Java算法系列》的细品就在于对代码和逻辑本身解析，而不仅仅局限于图解。

但是，但是

讲解的再好，也不及你自己动手后去参考，去思考的万分之一。

一定要清楚这一点

想和做隔着巨大的鸿沟。

细品就懂的两数之和

一、题目

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

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

细品就懂的两数之和

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

方法一：暴力枚举

暴力枚举比较直观，你只要理解双层for循环就明白了。

第一次双层for循环

第一个循环 i 从 0 下标开始执行一次。

而第二个循环 j 从 1 下标开始遍历所有数组。

j = i + 1

相加匹配我们的目标值，如果没有继续循环遍历。

if(nums[i] + nums[j] == target)

例如相加依然没有等于target条件， i 将为 1。

而 j 从2下标开始遍历所有数组。

以此类推

class Solution {
    public int[]  twoSum(int[] nums, int target) {

        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];
     	}
   }

public class TwoSum {
    public static void main(String[] args) {
        int[] list = {2,6,2,3,4,1};
        int[] res = new Solution().twoSum(list,4);
        System.out.print(Arrays.toString(res));
    }
}

运行结果
在这里插入图片描述

方法二：哈希表

方法一：暴力枚举时间复杂度较高（花费时间多，最坏情况下两个数可要都匹配一次），而哈希表可以快速寻找数组中是否存在目标元素。

但是，但是很多人对哈希表是懵的，导致的结果就算码不出来。

其实理解哈希表并不难，我们大胆想象，小心求证。

首先还是一个for循环遍历数组（这里只需一个）。

看到哈希 hash，还有代码里用的 HashMap。

你会想到 key-value 键值对形式，所以会利用上 key 唯一键这一特性。 map<数值，下标>

（在HashMap中key是唯一，一旦后面添加的key跟前面的key重复，后面的key会覆盖前面key，前面key不会消失，会变为 null）

在定义集合时，最好初始容量。

new HashMap<>(nums.length - 1)

HashMap<Integer,Integer> map = new HashMap<>(nums.length - 1);

再往下，会有点绕，但是我们只要明确我们的目标拿到的是两数之和的下标就清晰多了。

我们先绕过 if 语句来先看下面这条代码块。

每次 if 条件不成立都会遍历的分别将数组数字存进 key 而下标存 value里。

map.put(nums[i], i);

而这里的 if 条件是目标值 target 减去数组数字 nums[i]。

通过 containsKey 验证键值对是否存在此KEY

  if (map.containsKey(target - nums[i]))

这里if条件语句作用只是为了判断第二个数，因为第一个数已经put进入了。

而target目标数减去数组数如果等同于已经put进入的第一个key。

说明就是两数之和。

这也是我为什么要先说put这条代码块的原因。

第一个数，已经被put进去了。

可以看到，如果 if 条件成立，就可以通过 key 获取到 value 的值。

而 map.get(target - nums[i]) 的值恰恰就是通过匹配 key，获取 value，也就是获取数组的下标。

说明当前 target 的第一个数字已经存入 put 中，而第二个数字正是当前下标，也就是当前的 i

int[]{map.get(target - nums[i]), i};

class Solution {
    public int[]  twoSum(int[] nums, int target) {
     HashMap<Integer,Integer> map = new HashMap<>(nums.length - 1);
		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];
   	}
 }

public class TwoSum {
    public static void main(String[] args) {
        int[] list = {2,6,2,3,4,1};
        int[] res = new Solution().twoSum(list,4);
        System.out.print(Arrays.toString(res));
    }
}