1.两数之和+20.有效的括号

题目1 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

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

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

解法 1–双重循环遍历

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            if((target-nums[i] in nums) and (nums.index(target-nums[i]) != i)):
                return [i, nums.index(target-nums[i])]```

解法 2–字典保存value

这个解法有个地方很有意思,就是当你的列表为[6,6],12 时,你的 dict 实际上是会被重置一次key 为 6 时的 value 的,但是因为本题目明确说了只会有一个答案,所以这种情况也是被包含了.而[6,6,6],12 是不会出现在题目中的.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashmap = {}
        for index, value in enumerate(nums):
            hashmap[value] = index
        for i in range(len(nums)):
            j = hashmap.get(target-nums[i])
            if j is not None and j != i:
                return [i, j]

题目20 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: "()"
输出: true
示例 2:

输入: "()[]{}"
输出: true
示例 3:

输入: "(]"
输出: false
示例 4:

输入: "([)]"
输出: false
示例 5:

输入: "{[]}"
输出: true

解法–栈

栈是显而易见的解法,这里优化的地方是奇数长度的 s 必不满足,不需要考虑.

class Solution:
    def isValid(self, s: str) -> bool:
        if(len(s) % 2 == 1):
            return False
        stack = []
        for i in s:
            if len(stack) == 0:
                stack.append(i)
                continue
            if match(stack[-1], i):
                stack.pop()
            else:
                stack.append(i)
        if len(stack) == 0:
            return True
        else:
            return False


def match(s1: str, s2: str) -> bool:
    if (s1 == '(' and s2 == ')') or (s1 == '{' and s2 == '}')or (s1 == '[' and s2 == ']'):
        return True
    else:
        return False

新学到知识

1. 类型注解

def add(x:int, y:int) -> int:
    return x + y

用 : 类型 的形式指定函数的参数类型，用 -> 类型 的形式指定函数的返回值类型。

然后特别要强调的是，Python 解释器并不会因为这些注解而提供额外的校验，没有任何的类型检查工作。也就是说，这些类型注解加不加，对你的代码来说没有任何影响：

2. 迭代器

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象.
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

x = [1,2,3,4]
it = iter(x)# 初始化的it是空值的,不能直接访问
value = next(it) # it的类型是list_iterator object,next()和value的类型是int

3. 获取for循环中的index

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

lists = [1,2,3,4]
for index,value in enumerate(lists):
    print("%s--%s" %(index,value))

4. 判断值是否在list中

nums=[1,2,3]
num = 5
if(num in nums):
    print(1111)

5. 返回list中给定值的下标

逻辑:从列表中找出某个值第一个匹配项的索引位置

list.index(obj)

6. python dict的底层实现是用hash表

7. python没有专门的stack结构,用list实现

入栈操作–>append()
出栈操作–>pop()

stack = [3,4,5]
stack.append(6)
stack.append(7)#[3,4,5,6,7]
stack.pop()#[3,4,5,6]
stack.pop()#[3,4,5]

更多不知道你感不感兴趣的信息，可以关注一下我的公众号