1. 两数之和

题目： 两数之和
两数之和
已知：
整数数组 nums，整数目标值 target，找出和为目标值得两个整数，返回下标。
条件：
有唯一解，同元素不能重复出现。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

输入：nums = [3,2,4], target = 6
输出：[1,2]
解释：因为 nums[1] + nums[2] == 6 ，返回 [1, 2] 。

这道题拿过来之后很容易想到就是暴力解法，采用排列组合的思路。代码如下：

vector<int> twoSum(vector<int>& nums, int target) {   
	vector<int> result;								 	
	for (int i = 0; i < nums.size(); i++) {
		for (int j = 0; j < nums.size(); j++) {
			if (nums[i] + nums[j] == target) {
				result.push_back(i);								
				result.push_back(j);										
				return result;
			}
		}
	}
	return result;
}

但是真正在执行的时候，发现了问题，没有考虑边界条件。写完算法思路，怎么能不考虑边界条件呢？此段代码value[0] + value[0] = 6也是可以的，这个bug没有考虑到。而且是真暴力解法，一点别的脑子都没有动呢。

加了边界条件判断：

vector<int> twoSum_A(vector<int>& nums, int target) {
	vector<int> result;
	for (int i = 0; i < nums.size(); i++) {
		for (int j = 0; j < nums.size(); j++) {
			if (i == j)
				continue;
			if (nums[i] + nums[j] == target ) {
				result.push_back(i);
				result.push_back(j);
				return result;
			}
		}
	}
	return result;
}

这个代码才算是能用。但其实循环变量存在重复比较的问题，这个我没有仔细思考，没有仔细想过程，很不细心。优化掉循环变量重复比较的问题：

vector<int> twoSum_A(vector<int>& nums, int target) {
	vector<int> result;
	for (int i = 0; i < nums.size(); i++) {
		for (int j = i + 1; j < nums.size(); j++) {
			if (nums[i] + nums[j] == target ) {
				result.push_back(i);
				result.push_back(j);
				return result;
			}
		}
	}
	return result;
}

和leetcode中答案比较，发现其实返回值部分也可以换一种方法写，那种更为优雅。
优化返回值写法:

vector<int> twoSum_A(vector<int>& nums, int target) {
	vector<int> result;
	for (int i = 0; i < nums.size(); i++) {
		for (int j = i + 1; j < nums.size(); j++) {
			if (nums[i] + nums[j] == target ) {
				return {i,j};
			}
		}
	}
	return {};
}

以上的代码时间复杂度都是O(n2)。
从思路上来说，value = target - nums[i]，问题变成了搜索数组中是否有value。于是，有新的写法：

vector<int> twoSum_B(vector<int>& nums, int target) {
	vector<int> result;
	for (int i = 0; i < nums.size(); i++) {
		for (int j = i + 1; j < nums.size(); j++) {
			int temp = target - nums[i];
			if (nums[j] == temp) {
				return {i,j};
			}
		}
	}
	return {};
}

搜索方式是遍历数组，那么遍历的时间复杂度是O(n)，可以使用Hash去优化搜索方式，将O(n)变为O(1)。然后我就开始写了：

vector<int> twoSum_C(vector<int>& nums, int target) {
	vector<int> result;
	unordered_map<int, int> hash;
	for (int i = 0; i < nums.size(); i++) {
		hash[nums[i]] = i;
		//hash.insert(pair<int, int>(nums[i], i));
	}
	for (int i = 0; i < nums.size(); i++) {
		int value = target - nums[i];
		if (hash.end() != hash.find(value) && hash[value] != i) {
			//found
			result.push_back(i);
			result.push_back(hash.find(value)->second);
			break;
		}
	}
	return result;
}

思路是首先构建Hash表，然后在其中查询。这样的遍历方式时间复杂度是O(n)。但是看Leetcode上的实现显然比我的简洁：

 vector<int> twoSum(vector<int>& nums, int target) {
	vector<int> result;
	unordered_map<int, int> hash;
	for (int i = 0; i < nums.size(); i++) {
		auto it = hash.find(target - nums[i]);
		if (it != hash.end()) {
			return { i,it->second };
		}
		hash[nums[i]] = i;
	}
	return {};
    }

这里的hash表，比较巧妙，把构建hash表和查找hash表放到了一个循环中，这样循环次数是最小的。时间复杂度是O(n)。

vector<int> twoSum(vector<int>& nums, int target) {
	vector<int> result;
	map<int, int> tree;
	for (int i = 0; i < nums.size(); i++) {
		auto it = tree.find(target - nums[i]);
		if (it != tree.end()) {
			return { it->second,i };
		}
		tree[nums[i]] = i;
	}
	return {};
}

总结

写算法的时候暴露了我自己的一些不足：

• 写算法只考虑实现功能，不考虑边界条件
• 变量优化，认真仔细，不能粗心大意大大咧咧
• 遇到搜索问题，使用二叉树和hash表的时间复杂度会比较小一些
• 构建hash表和搜索，这两个过程可以合到一起