LeetCode01----两数之和

描述：
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解答：
java版本

package com.csylhscala.javaTest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Solution {
    //TODO 方法一：暴力法
     //分析：时间复杂度O（n^2）
     //     空间复杂度O（1）
    public static int[] twoSum01(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] == target - nums[i]) {
                    return new int[] { i, j };
                }
            }
        }
        return null;
    }
    //TODO 方法二：2遍hash表

    //为了时间复杂度的优化，我们采用空间换取时间的办法进行  两遍哈希表
    // map.containsKey()该方法判断Map集合对象中是否包含指定的键名。如果Map集合中包含指定的键名，则返回true，否则返回false。
    public static int[] twoSum02(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>(nums.length);
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        //第二次遍历，只是寻找，时间复杂度O（1）
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement) && map.get(complement) != i) {
                return new int[] { i, map.get(complement) };
            }
        }
        return null;
    }
    //TODO 方法三：一遍hash表
    //时间复杂度O（n），循环遍历n个元素的数组一次 ，每一次比较花费O（1）的时间
    //空间复杂度O（n），Hash表中最多会存储数数组.length（）个长度元素
    public static int[] twoSum03(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>(nums.length);
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }else {
                map.put(nums[i], i);
            }
        }
        return null;
    }
    public static void main(String[] args){
        int[] jj = new int[]{1,2,9,7};
        System.out.println(Arrays.toString(Solution.twoSum01(jj,10)));
        System.out.println(Arrays.toString(Solution.twoSum02(jj,10)));;

        System.out.println(Arrays.toString(Solution.twoSum03(jj,10)));;

    }
}

python版本:

-- coding: utf-8 --

@Time : 2018/8/6 10:34

@Author : 留歌36

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，

同时列出数据和数据下标，一般用在 for 循环当中

class Solution(object):

def twoSum01(self, nums, target):

    for index, value in enumerate(nums):
        complement = target - value
        if complement in nums:
            return [index, nums.index(complement)]

if name == ‘main‘:
solution = Solution()
print(solution.twoSum01([1,3,4],7))

**scala版本：**

package com.csylhscala.scalaTest

import java.util
import java.util.{HashMap, Map}

object Solution {
def twoSum(nums: Array[Int], target: Int) :String= {
val map: util.Map[Integer, Integer] = new util.HashMapInteger, Integer
var i: Int = 0
while (i < nums.length) {
val complement: Int = target - nums(i)
if (map.containsKey(complement)){
return util.Arrays.toString((Array[Int](map.get(complement), i)))
}
else{
map.put(nums(i), i)
i+=1
}
}
null
}
def main(args: Array[String]): Unit = {
var jj = Array[Int](1, 2, 9, 7)
println(twoSum(jj,10))
}
}
“`