LeetCode1：两数之和

人工智能菜鸡

于 2022-07-09 22:13:01 发布

阅读量1.6k

点赞数

分类专栏： leetcode 文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/weixin_42155801/article/details/125699654

版权

leetcode 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

题意：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案

示例：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

我的解法：解答错误

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        l = len(nums)
        list = []
        for i in range(l):
            if nums[i] < target:
                for j in range(i,l):#应该是i+1
                    if nums[j] < target and nums[i] + nums[j] == target:
                            list.append(i)
                            list.append(j)
                            return list
                    j += 1 
            i += 1

结果：通过测试用例：13 / 57。输入：[3,2,4] 6 希望输出：[1,2]，实际输出：[0,0]。

1.for j in range(i,l)改为for j in range(i+1,l)，通过测试用例：22 / 57 输入：[0,4,3,0] 0希望输出：[0,3]，实际输出：null。

2.if nums[i] < target:改为if nums[i] ≤ target 输入：[-3,4,3,1] 0 希望输出：[0,2]，实际输出：null

分析：题目并没有给出所给数组元素均大于0，但做题的时候根据示例默认了所给数组元素大于0。

3.为什么要 j += 1、i += 1，又不是while条件语句，稀里糊涂的！！

纠正代码：

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

优化一下这个暴力枚举：

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

复杂度分析:

时间复杂度：O(N^2)，其中 N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
空间复杂度：O(1)

官方解法

### 方法一：暴力枚举

#### 思路：

最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。

当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们**只需要在 x 后面的元素中**寻找 target - x。

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

#### 复杂度分析

- 时间复杂度：O(N^2)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
- 空间复杂度：O(1)。

方法二：哈希表

#### 思路与算法：

注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。

使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。

这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。


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

#### 分析：

两个元素x，y必然是一前一后出现的，如果存在符合条件的解，在遍历到x时，哈希表里没有符合的y，此时把x加入到了哈希表里，当遍历到y时，就可以在哈希表里找到对应的x了，所以只需要一次遍历

#### 复杂度分析

时间复杂度：O(N)，其中 N是数组中的元素数量。对于每一个元素 x，我们可以 O(1)地寻找 target - x。

空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。

python函数充电站

### 一.python怎么向列表中添加多个元素



**总结**：

- **append(obj)**末尾添加单个元素（单个元素可指元组、列表）；
- **extend(obj)**末尾添加单/多个元素；
- **insert(index , obj)**指定索引添加单个元素。

#### 1.通过使用“+”[运算符](https://so.csdn.net/so/search?q=运算符&spm=1001.2101.3001.7020)可以将多个列表进行连接

name = ["python学习网"]

address = ["https://www.py.cn"]

print(name+address)


output：
['python学习网', 'http:s//www.py.cn']

#### 2.append()

append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：

listname.append(obj)

其中，**listname **指的是要添加元素的列表；**obj **表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

a_list = ['crazyit', 20, -2]

# 追加元素

a_list.append('fkit')

print(a_list)

# 追加元组，元组被当成一个元素

a_tuple = (3.4, 5.6)

a_list.append(a_tuple)

print(a_list)

# 追加列表，列表被当成一个元素

a_list.append(['a', 'b'])

print(a_list)

output:

['crazyit', 20, -2, 'fkit']

['crazyit', 20, -2, 'fkit', (3.4, 5.6)]

['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]

#### 3.extend()

不希望将被追加的列表或元组当成一个整体，而是**只追加列表中的元素**，则可使用列表提供的 extend() 方法。

extend()方法的语法格式如下：

listname.extend(obj)

例如：

b_list = ['a', 30]

# 追加元组中的所有元素

b_list.extend((-2, 3.1))

print(b_list)

# 追加列表中的所有元素

b_list.extend(['C', 'R', 'A'])

print(b_list)

# 追加区间中的所有元素

b_list.extend(range(97, 100))

print(b_list)

输出：

['a', 30, -2, 3.1]

['a', 30, -2, 3.1, 'C', 'R', 'A']

['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

#### 4.insert()

在列表中间增加元素，则可使用列表的 insert() 方法，此方法的语法格式为：

listname.insert(index , obj)

其中，index 参数指的是将元素插入到列表中指定位置处的索引值。

使用 insert() 方法向列表中插入元素，和 append() 方法一样，无论插入的对象是列表还是元组，**都只会将其整体视为一个元素**。

例如：

c_list = list(range(1, 6))

print(c_list)

# 在索引3处插入字符串

c_list.insert(3, 'CRAZY' )

print(c_list)

# 在索引3处插入列表

c_list.insert(3, ["crazy"])

print(c_list)

输出结果为：

[1, 2, 3, 4, 5]

[1, 2, 3, 'CRAZY', 4, 5]

[1, 2, 3, ['crazy'], 'CRAZY', 4, 5]

### 二.python中字典的定义和操作



字典的格式：字典名 = {key1:value1, key2:value2,...}

字典的key是不能重复的 但value可以

#### 1.定义一个空的字典

my_dict = {}   
或
my_dict = dict()

#### 2.字典的常见操作

定义一个字典：

my_dict = {"name": "小明", "age": 18, "no": "007"}

**（1）查看元素(通过key 获取value)**

value = my_dict["no"]

**（2）修改元素**

如果key 存在 那么会修改key 对应的value

如果key 不存在那么将把这个键值对添加到字典中


# key 存在
my_dict["age"] = 19
print(my_dict)
# key不存在
my_dict["test"] = "测试"
print(my_dic

**（3）删除元素**

del 删除指定的元素 格式：del 字典名[key] 删除元素（key-value）

del my_dict["name"]

clear() 清空字典中所有的元素

my_dict.clear()

**（4）计算元素的个数**

l = len(my_dict)

**（5）返回一个包含字典的所有key/value的列表   keys()/values()**

keys_list = my_dict.keys()

values_list = my_dict.values()

**（6）返回一个包含所有（键、值）元组的列表  items()**

my_dict = {"name": "小明", "age": 18, "no": "007"}
items_list = my_dict.items()
items_list
Out[1]: dict_items([('name', '小明'), ('age', 18), ('no', '007')])
print(list(items_list))
Out[2]: [('name', '小明'), ('age', 18), ('no', '007')]

**（7）判断key是否存在**

  in 存在 not in 不存在

if "name" in my_dict:
    print("name存在")

**（8）get()**

my_dict.get(key)

如果key 存在得到value
如果key 不存在得到None 没有找到

ret = my_dict.get("gender")

my_dict.get(key, value1)

如果key存在得到value ;
如果key不存在得到value1 不会对字典进行任何操作.

#### 3.字典的遍历

（1）遍历key/value

for key in my_dict.keys():

for value in my_dict.values():

（2）遍历items

for item in my_dict.items():
    print(item)
    
output:
('name', '小明')
('age', 18)
('no', '007')

**（3）遍历items得到对应的key value**

for key, value in my_dict.items():
    print(key, value)
    
output:    
name 小明
age 18
no 007

**（4）区分：enumerate()实现带下标索引的遍历**

通过遍历可以获取**字符串,列表,元组**得到对应的元素和元素的下标索引

my_list = ["fgg", "rth", "rkz"]
for index, value in enumerate(my_list):
    print(index, value)

输出：

0 fgg
1 rth
2 rkz

人工智能菜鸡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录