LeetCode-1. Two Sum

1. 问题描述

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,

return [0, 1].

2. 解法描述

2.1 暴力穷举

进行两层遍历，满足题目要求的条件时退出。

显然该算法的时间复杂度为O(n2)，空间复杂度为O(1)。

public int[] twoSum1(int[] nums, int target) {
int[] result = new int[]{0,0};
for(int i = 0; i < nums.length - 1; i ++ ) {
for (int j = i + 1; j < nums.length; j ++) {
if ((nums[i] + nums[j]) == target) {
result[0] = i;
result[1] = j;
break;
}
}
}

return result;
}

更加优雅的版本：

public int[] twoSum2(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[j] == target - nums[i]) {
return new int[] { i, j };
}
}
}
throw new IllegalArgumentException("No two sum solution");
}

2.2 优化

暴力穷举法使用了两层遍历，其中第二层遍历的目的是为了寻找数组中是否存在某元素，若存在，则返回的结果是该元素在数组中对应的下标，其时间复杂度为O(n)。显然，此处通过

HashMap

来优化，因为在

HashMap

检测某元素是否存在的时间复杂度为O(1)。

优化版：

public int[] twoSum3(int[] nums, int target) {
Map<Integer, Integer> value2index = new HashMap<>();

for (int i = 0; i < nums.length; i ++) {
value2index.put(nums[1], i);
}

for (int i = 0; i < nums.length; i ++) {
int key = target - nums[i];
if (value2index.containsKey(key) && value2index.get(key) != i) {
return new int[]{i, value2index.get(key)};
}
}

throw new IllegalArgumentException("No two sum solution");
}

该算法时间复杂度为O(n+n)→O(n)，空间复杂度为O(n)。

优雅版：

public int[] twoSum4(int[] nums, int target) {
Map<Integer, Integer> value2index = new HashMap<>();
for(int i = 0; i < nums.length; i ++) {
int key = target - nums[i];
if(value2index.containsKey(key)) {
int index = value2index.get(key);
return new int[]{index, i};
}
value2index.put(nums[i], i);
}
throw new IllegalArgumentException("no two sum solution");
}

参考

Two Sum