原创：悦乐书 程序员小川

给定一个整数数组，找出其中两个数相加等于目标值

例如：给定数组及目标值 nums = [2,7,11,15] ,target = 9
因为nums[0] + nums[1] = 2 + 7 = 9
返回[0,1]
利用HashMap

解法一：

这道题目求的是数组内任意两元素之和等于给定的目标整数，于是很容易想到数组for循环遍历，并且是两层for循环，于是第一版的代码思路已经有了。

//java代码实现
private int[] findData(int[] array,int target){
   int[] result={-1,-1};
   HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
   for(int i=0;i<array.length;i++){
      map.put(array[i],i); 
     }

 for(int i=0;i<array.length;i++){
      int two = target-array[i];
     if(map.containKey(two)&&target!=2*two){
          result[0]=i;
         result[1]=map.get(two);
         break;
   }
 }
 retrurn result;
}

//Kotlin代码实现
fun twoSum1(nums: IntArray, target: Int): IntArray? {
            var result = IntArray(2)
            if (nums.size < 2)
                return null
            for (i in 0..nums.size-1) {
                for (j in i + 1..nums.size-1) {
                    if (nums[i] + nums[j] == target) {
                        result[0] = nums[i]
                        result[1] = nums[j]
                    }
                }
            }
            return result;
        }

解法二：

上面的解法是两层循环，循环次数是n*(n-1)次，n为数组元素个数，n越大，程序执行的时间越长，那能不能只循环一次？既然可以做加法匹配，那做减法呢？先拿到目标整数与数组中每位元素的差值，再去判断此差值是否存在于此数组中。这时，我们需要一个存新数据的集合，既包含每位元素，也包含每位元素的索引，对此选取Map作为存放新数据的对象。

 //java实现
 public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        int[] result=new int[2];
        for(int i=0;i<nums.length;i++){
            int value = target-nums[i];
            if(map.containsKey(value))
            {
               result[0]=i;
               result[1]=map.get(value);
                break;
            }          
            map.put(nums[i],i);
        }
        return result;
        
    }

//Kotlin实现
 fun twoSum2(nums: IntArray, target: Int): IntArray? {
            var result = IntArray(2)
            if (nums.size < 2)
                return null
            var map = HashMap<Int, Int>()
            for (i in 0..nums.size-1) {
                val k = target - nums[i]
                if (map.containsKey(k)) {
                    result[0] = nums[map.get(k)!!]
                    result[1] = nums[i]
                    break
                }
                map.put(nums[i], i)
            }
            return result
        }