1.两数之和

给定一个整数数组 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
**

解法一：穷举

class Solution {
public:
	vector<int> twoSum(vector<int>& nums, int target) 
	{
		vector<int> indexs;
		for (int i = 0; i < nums.size(); i++)
		{
			for (int j = i + 1; j < nums.size(); j++)
			{
				if (nums[i] + nums[j] == target)
				{
					indexs.push_back(i);
					indexs.push_back(j);
				}

			}
		}
		return indexs;
	}
};

时间复杂度：O(n^2)
空间复杂度：O(1)

解法二：穷举（改进）

class Solution {
public:
	int findIndex(vector<int>& ary, int data, bool repeat)
	{

		for (int i = 0; i < ary.size(); i++)
		{
			if (ary[i] == data)
			{
				if (repeat == false) return i;
				else
				{
					repeat = false;
					continue;
				}
			}
		}
		return -2;
	}
	vector<int> twoSum(vector<int>& nums, int target)
	{
		vector<int> indexs;
		vector<int> backup(nums);
		sort(nums.begin(), nums.end());
		for (int i = 0; i < nums.size(); i++)
		{
			if (nums[i] > target) break;
			for (int j = i + 1; j < nums.size(); j++)
			{
				if (nums[i] + nums[j] > target)
				{
					break;
				}
				else
				{
					if (nums[i] + nums[j] == target)
					{
						indexs.push_back(findIndex(backup, nums[i], false));
						if (nums[i] == nums[j])
						{
							indexs.push_back(findIndex(backup, nums[j], true));
						}
						else indexs.push_back(findIndex(backup, nums[j], false));

						return indexs;
					}
				}
			}
		}
		return indexs;
	}
};

解法三：哈希表

class Solution {
public:
	vector<int> twoSum(vector<int>& nums, int target)
	{
		map<int, int> hashMap;
		vector<int> index;
		for (int i = 0; i < nums.size(); i++)
		{
			if (hashMap.count(target - nums[i]))
			{
				index.push_back(hashMap[target - nums[i]]);
				index.push_back(i);
				return index;
			}
			else
			{
				hashMap.insert(map<int, int>::value_type(nums[i], i));
			}
		}
		return index;
	}
};

时间复杂度：O(n)
空间复杂度：O(n)