Leetcode（1）两数之和

[题目表述]：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

第一种方法：暴力

执行用时：5352 ms； 内存消耗：12.9MB 效果：非常差

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(0,len(nums)):
            for j in range(i+1,len(nums)):
                if((nums[i]+nums[j])==target):
                    return [i,j]

第二种方法：首尾递归查找

执行用时：60 ms； 内存消耗：13.3MB 效果：非常好

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        sorted_id = sorted(range(len(nums)), key=lambda k: nums[k])    //学到了
        head = 0
        tail = len(nums) - 1
        sum_result = nums[sorted_id[head]] + nums[sorted_id[tail]]
        while sum_result != target:
            if sum_result > target:
                tail -= 1
            elif sum_result < target:
                head += 1
            sum_result = nums[sorted_id[head]] + nums[sorted_id[tail]]
        return [sorted_id[head], sorted_id[tail]]

学习

• sorted排列
  sort与sorted区别：
  sort是应用在list上的方法，sorted可以应用到所有可迭代对象上
  sort返回的是对已存在的列表进行操作，sorted返回的是一个新的list
  sorted(iterable,key,reverse)：
  iterable是迭代对象，key缺省则是不以key函数形式进行，有key则意思是按key的函数形式进行排序，reverse=F升序，=T降序，缺省是升序
  => key=lambda 隐函数 这是关键，如上述的key=lambda k: nums[k]，意味着range(len(nums))的值
  按照nums[k]的大小，k相当于是迭代器。
• lambda隐函
• 算法思想：
  首尾递归，少了就移动头，多了移动尾

第三种方法：字典 / 哈希表

执行用时：56 ms； 内存消耗：13.5MB 效果：最好效果基本上

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        hashmap = {}
        for index, num in enumerate(nums):
            another_num = target - num
            if another_num in hashmap:    //字典中的查找是否存在对应键
                return [hashmap[another_num], index]
            hashmap[num] = index
        return None

学习

• 字典+枚举 键值对查找
• enumerate()
  字典上是枚举的意思，对一个可迭代对象，将其组成一个索引列表，利用它同时获得索引和值
  多用于在for循环中得到计数：for index, num in enumerate(nums):
  第二个参数值，用于指定索引起始值
• hash思想

第四种方法：list查询 / 哈希

执行用时：811 ms； 内存消耗：12.6MB

class Solution:
    def twoSum(self, nums, target):
        i = 0
        while i < len(nums):
            if i == len(nums) - 1:
                return "No solution here!"
            r = target - nums[i]
            # Can't use a num twice
            num_follow = nums[i + 1:]
            if r in num_follow:
                return [i, num_follow.index(r) + i + 1]
            i = i + 1

学习：

• if r in num_follow 查询num_follow列表中是否有r这个值

原文地址：https://www.cnblogs.com/ymjun/p/11645040.html