LeetCode笔记-0001-两数之和

题目信息

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目解答

解法一：“暴力破解”

拿到题目，第一反应是暴力破解…双层for循环，一个一个的往后遍历，时间复杂度为O(n^2)，空间复杂度为O(1)，代码如下：

/**
* 最粗暴的解决方案，双层遍历循环
* 时间复杂度 ： O(n^2)，双层循环
* 空间复杂度 ： O(1)，只需要一个临时变量来存储
*
* @param nums
* @param target
* @return
*/
public int[] twoSumByViolence(int[] nums, int target) {
    if (nums == null || nums.length < 2)
		throw new IllegalArgumentException("数组长度错误！！");
	int numsLength = nums.length;
	int target1 = 0;
	for (int i = 0; i < numsLength; i++) {
		target1 = nums[i];
		for (int j = i + 1; j < numsLength; j++) {
			if (nums[j] == target - target1)
				return new int[]{i, j};
		}
    }
   throw new IllegalArgumentException("没有符合条件的结果！");
}

解法二：“空间换时间”(哈希)

暴力破解的方式，时间复杂度为O(n^2)，耗时较长，分析题目可以知道我们实际要做的工作就是拿着一个变量找到另外一个遍历相加等于target并返回它们的索引，寻找另外一个变量消耗了O(n)的时间，我们可以利用hash表来降低查找时间。hash表维持近似恒定（发生冲突会变成O(n)）效率进行查询，所以hash算法的选择会决定查询时间。
在第一次迭代中，将值和索引放到哈希表中，在第二次迭代中，检查目标值（target - nums[i]）是否存在于表中且该值不是nums[i]本身。代码如下：

/**
* 利用map，
* 这种方式存在问题：若数组存在相同的数据，后面的索引会在put的时候覆盖掉前面的索引
* 如：{2,2,5,4,1} 7  会返回 {1,2}，并不会返回{0,2}
* 时间复杂度 ： O(n)
* 空间复杂度 ： O(n)
* 题目中有标出**可以假设每种输入只会对应一个答案**，所以不会存在描述的问题
*
* @param nums
* @param target
* @return
*/
public int[] twoSumByTwoHash(int[] nums, int target) {
	if (nums == null || nums.length < 2)
		throw new IllegalArgumentException("数组长度错误！！");
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	int numsLength = nums.length;
	for (int i = 0; i < numsLength; i++) {\\第一次迭代中，将值和索引放到哈希表中
		map.put(nums[i], i);
	}
	int target1 = 0;
    //第二次迭代中，检查目标值（target - nums[i]）是否存在于表中且该值不是nums[i]本身
	for (int i = 0; i < numsLength; i++) {
		target1 = target - nums[i];
		if (map.containsKey(target1) && map.get(target1) != i)
		    return new int[]{i, map.get(target1)};
	}
	throw new IllegalArgumentException("没有符合条件的结果！");
}

解法三：优化后的哈希

在解法二中我们利用了HashMap的特性降低了查询时间，但我们可以同时进行将放入哈希表和检查目标值两个步骤，代码如下：

/**
* 单次Hash算法求和
* 问题：数据重复时，不能保证输出顺序
* [3,4,4,7,2,11,15]
* 8
* [2,1]
* [1,2]
* 时间复杂度 ： O(n)
* 空间复杂度 ： O(n)
*
* @param nums
* @param target
* @return
*/
public int[] twoSumByOneHash(int[] nums, int target) {
	if (nums == null || nums.length < 2)
		throw new IllegalArgumentException("数组长度错误！！");
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	int numsLength = nums.length;
	int target1 = 0;
	for (int i = 0; i < numsLength; i++) {
		target1 = target - nums[i];
		if (map.containsKey(target1))
			return new int[]{i, map.get(target1)};
		map.put(nums[i], i);
	}
	throw new IllegalArgumentException("没有符合条件的结果！");
}