题目

给定一个整数数组 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
  • 只会存在一个有效答案

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

方法一：暴力破解法

分析

下意识的解题思路可能都是这个方式，使用嵌套循环并逐一判断两个数之和是否为目标值。在这个方法的基础上，第二层循环只遍历第一层索引后的所有元素，避免重复比对，减少了总的遍历次数。这个方法是最容易想到的办法，但是这个方法的执行用时为54ms，内存消耗为41.4MB，时间复杂度为O(n2)，空间复杂度为O(1)。

代码

  1. class Solution {
  2.     public int[] twoSum(int[] nums, int target) {
  3.         int[] result = new int[2];
  4.         for (int i = 0; i < nums.length; i++) {
  5.             for (int j = i+1; j < nums.length; j++) {
  6.                 if(nums[i] + nums[j] == target){
  7.                     result[0] = i;
  8.                     result[1] = j;
  9.                     return result;
  10.                 }
  11.             }
  12.         }
  14.         return result;
  15.     }
  16. }

方法二：Map标记法

分析

该解题方法使用Map进行标记遍历过的元素，值->索引的形式存入，并在循环中判断每个元素需要的对应值是否在Map中，实现高效的解题方式，充分的利用题目中的条件，使用动态规划的概念进行实现，次方法的执行用时1ms，内存消耗41.4MB，时间复杂度为O(n2)，空间复杂度O(n)。

代码

  1. class Solution {
  2.     public int[] twoSum(int[] nums, int target) {
  3.         int[] result = new int[2];
  4.         HashMap<Integer, Integer> map = new HashMap<>();
  5.         int num2;
  7.         for (int i = 0; i < nums.length; i++) {
  8.             num2 = target - nums[i];
  9.             if (map.containsKey(num2)) {
  10.                 result[0] = map.get(num2);
  11.                 result[1] = i;
  12.                 break;
  13.             }
  14.             map.put(nums[i], i);
  16.         }
  18.         return result;
  19.     }
  20. }