LeetCode第一天（两数之和答案解析）

暴力枚举：双重循环，固定一个元素，循环其他元素直到匹配成功，失败返回空数组

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 循环上限
        int len = nums.length;
        // 遍历数组内所有元素
        for(int i = 0;i<len;++i){
            //每次遍历一个元素就匹配后面的元素，直到匹配成功
            for(int j = i+1;j<len;++j){
                // 符合条件返回两数下标
                if(nums[i]+nums[j] == target){

                    return new int[]{i,j};
                }
            }
        }
        // 没找到返回空数组，避开报错
        return new int[0];

    }
}

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        numsLen = len(nums)
        for i in range(numsLen):
        #  此处注意写法，应当把i+1放入range重新开始循环  
            for j in range( i + 1,numsLen):
                if nums[i] + nums[j] == target:
                    return [i,j]
        return []

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
        var lens = nums.length;
        for(var i = 0 ;i<lens;++i){
            for(var j = i + 1 ;j<lens;++j){
                if(nums[i] + nums[j] == target){
                    return [i,j];
                }
            }
        }
        return [];
};

function twoSum(nums: number[], target: number): number[] {
    const lens:number = nums.length;
    for(var i:number = 0; i< lens; ++i){
        for(var j:number = i+1; j<lens ; ++j){
            if(nums[i] + nums[j] == target)return [i,j];
        }
    }
    return [];
};

哈希表法

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 循环上限
        int len = nums.length;
        // 创建哈希表
        Map<Integer,Integer> hashTable = new HashMap<Integer,Integer>();
        // 遍历数组内所有元素
        for(int i = 0;i<len;++i){
            // 如果哈希表内包含target - num[i] 的键，说明已经匹配了 
            if(hashTable.containsKey(target - nums[i])){
                // 返回匹配的下标数组
                return new int[]{hashTable.get(target - nums[i]),i};
            }
            // 没有匹配就把键值添加进去（以元素为键，下标为值）
            hashTable.put(nums[i],i);
        }
        // 没找到返回空数组，避开报错
        return new int[0];

    }
}

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        numsLen = len(nums)
        # 创建字典
        mapDir = {}
        for i in range(numsLen):
            if target - nums[i] in mapDir :
                return [mapDir[target - nums[i]], i]
            mapDir[nums[i]] = i
        return []

-----------------36ms

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

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
        let dirct = {}
        for(let i = 0 ;i<nums.length;++i){
           if(target - nums[i] in dirct){
                return [dirct[target - nums[i]], i];
           }
           dirct[nums[i]] = i;
        }
        return [];
};

function twoSum(nums: number[], target: number): number[] {
    let dirs:Object = {}
    for(var i:number = 0; i< nums.length; ++i){
        if(target - nums[i] in dirs)return [dirs[target - nums[i]], i];
        dirs[nums[i]] = i;
    }
    return [];
};