力扣第一题

之前在大学的时候，大一、大二的时候还是会刷刷算法题的，从大三之后再也没去学过了，更别说刷题了，慢慢的，完全忘记了，数据结构、算法是程序员的内功修炼，不可忽略，虽然难，也得迈出第一步。

力扣第一题

题目
给定一个整数数组 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) 的算法吗？

解
第一种解法，暴力求解。双重for 循环，去逐一判断两数之和是否等于target。

代码如下：

class Solution {
public int[] twoSum(int[] nums, int target) {
int length = nums.length;

    for (int i = 0; i < length - 1; i++) {
        for (int j = i + 1; j < length; j++) {
            if (nums[i] + nums[j] == target)
                return new int[] {i, j};
        }
    }
    return null;
}

}
这种解法，时间复杂度：O(N^2)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。空间复杂度为O(1)。

当然，还有更简单的解法。第一种方法，在找 target - i 是否存在时，又去遍历了一遍数组，导致时间复杂度很高，那我们就自然想到了，更快速找到target - i 是否存在，就属哈希表了。这样时间复杂度一下子，就从O(N) 降低到 O(1)。只不过空间复杂度增大了，为O(N) ，以空间换时间。

具体思路：

创建一个hashMap，遍历数组，第一个数，map 中肯定没有与之和为target，就先加入到map中，key 是具体的数值，value 是数组的下标，如果 target - nums[i] 不存在map中，就让其加入到map中，如果存在，就找到了，取 target - nums[i] 的value ，和 i。

代码：

class Solution {
public int[] twoSum(int[] nums, int target) {
int length = nums.length;
HashMap hashMap = new HashMap<>(length - 1);
hashMap.put(nums[0], 0);

    for (int i = 1; i < length; i++) {
        int another = target - nums[i];
        if (hashMap.containsKey(another)) {
            return new int [] {hashMap.get(another) , i};
        }
        hashMap.put(nums[i], i);
    }
    return new int [0];
}

}
这种方法的时间复杂度，为O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，实现了可以 O(1) 地寻找 target - x。

空间复杂度：O(N)，主要为哈希表的开销。