每日一题-两数之和

Java-简单粗暴解法

暴力枚举，使用双层循环计算x与x之后的元素，从而避免元素与自身相加

优点：简单，消耗内存低

缺点：执行时间过长

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    int[] resule = {i,j};
                    return resule;
                }
            }
        }
        return null;
    }
}

Java-哈希表

创建一个哈希表，查询哈希表中target-i是否存在，将i插入到哈希表中，避免i与自己匹配。

优点：速度快

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

Python-暴力枚举

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            x = target - nums[i]
            for j in nums[i+1:]:
                if x == j:
                    return [i,nums[i+1:].index(j)+i+1]

Python-哈希表

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hx = dict()
        for i,num in enumerate(nums):
            if target - num in hx:
                return [hx[target-num],i]
            hx[nums[i]] = i
        return []