leetcode之路001 Two Sum

一、Two Sum

给定一个整数的数组，让你找到两个数，使得他们的和为特定的一个数。返回这两个数的下标值，并且第一个必须小于第二个。题目假定对于特定的数，此数组总可以找到满足要求的数。例：

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

自己的思路：1、对于一个排序的数组，这个问题就变得很简单了，用两个指针，分别指向数组首和末，即fir和la，当两个值相加大于target，则，尾指针--，当两个值相加小于target，则头指针++，直到等于target。因为题目的假定，所有总可以找到符合的fir和la。

2、此题目输入数组不一定为有序，因此用sort进行排序，然后用1的思路进行求解。

3、sort排序后，数组下标变化了，如何将原数组和排序数组下标对应起来，这是个问题。解决办法：排序数组放到新数组num_copy中，找到fir和la后，

在原数组中进行查找操作，查找值为num_copy(fir)和num_copy(la)的元素，返回其下标即可。

4、查找值为num_copy(fir)和num_copy(la)的元素时，需要注意三点，一是，如果有重复元素，且num_copy(fir)和num_copy(la)恰为重复元素，这两个可能指向同一位置it1=it2，则需要将第二个下标从找到位置it1后面再去查找等于num_copy(la)的位置。二是，如果，it2<it1,则需要将两个位置交换输出。三是，vector下标从0开始的，找到的位置都需要+1输出。

为了方便本地测试，完整的代码如下：

#include<iostream>
#include<algorithm>
#include<vector>
#include<fstream>
#include<algorithm>
using namespace std;

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> num_copy(nums.begin(),nums.end());
		sort(num_copy.begin(),num_copy.end());//排序
		//int mm=lower_bound(nums.begin(),nums.end(),target)-nums.begin();
		vector<int> resu;
		int i=0,j=num_copy.size()-1;
		while(num_copy[i]+num_copy[j]!=target)  //循环在有序数组找到两个数的位置
		{
			if(num_copy[i]+num_copy[j]<target)
				++i;
			else if(num_copy[i]+num_copy[j]>target)
				--j;
		}
		vector<int>::iterator it1=find(nums.begin(),nums.end(),num_copy[i]);//原数组中查找
		vector<int>::iterator it2=find(nums.begin(),nums.end(),num_copy[j]);
		if(it1==it2)//相等，则重新查找第二个下标
		{
			vector<int>::iterator temp=it1;
			it2=find(++temp,nums.end(),num_copy[j]);
		}
		else if(it2<it1) //第二个下标更小，交换
			swap(it1,it2);
		int res_i=it1-nums.begin()+1;	//随机访问迭代器转换为整数
		int res_j=it2-nums.begin()+1;
		resu.push_back(res_i);
		resu.push_back(res_j);
		return resu;
    }
};

int main()
{	
	int a[4]={0,4,3,0};
	vector<int> nums(a,a+4);
//	ifstream cin("data.txt");  //测试输入
	Solution so;
	vector<int> rr;
	rr=so.twoSum(nums,0);
	copy(rr.begin(),rr.end(),ostream_iterator<int>(cout," "));
	return 0;
}

提交class Solution后，显示运行时间12ms，看来排序后速度果然快了不少。

查看讨论区，发现有更好更简洁的实现方式，利用hash_map，准确来说是unordered_map来实现的，很有借鉴价值，改写的代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> resu;
		unordered_map<int,int> hash;
		for(int i=0;i<nums.size();++i)
		{
			int neednum=target-nums[i];
			if(hash.find(neednum)!=hash.end())
			{
				resu.push_back(hash[neednum]+1);
				resu.push_back(i+1);
				return resu;
			}
			hash[nums[i]]=i;
		}
		return resu;
    }
};

2016.09.01更新 JAVA代码

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        if(nums == null) {
            return res;
        }
        Map<Integer, Integer> map = new HashMap<>();
        int key = 0;
        for(int i = 0; i < nums.length; i++) {
            key = target - nums[i];
            if(map.containsKey(key)) {
                res[0] = map.get(key);
                res[1] = i;
                break;
            } else {
                map.put(nums[i], i);
            }
        }
        return res;
    }
}