从零开始的LeetCode世界

我不喜欢这个世界，我只喜欢LeeCode

大家好呀，小夜斗今天要开始面向力扣学习啦，争取每天少打把王者，多刷几个力扣题目哈哈哈, 争取自己早日上岸呐！也希望正在为了未来努力奋斗的小伙伴们要坚持下去呐，不要轻易放弃呐！

在无人问津的地方努力，在万众瞩目的地方发光

一：两数之和

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

1. 暴力求解法: 两行for循环代码暴力求解，直到找到两个数字之和为target目标值为止，如果找到了则返回两个数字的索引，力扣上运行的代码如下!

• 时间复杂度为O($n^2$)

class Solution:
    def twoSum(self, nums: List[int], target: int) -> 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]

执行结果如下（提交成功）:

2. 哈希求解法: 通过构建一个字典，一次循环遍历，利用target值减去当前的数字值，看得到的结果是否存在于构建的字典当中，如果在，则返回对应的两个数字的索引，如果不在，则将该值当作key，索引i当作value存入到字典当中

• 时间复杂度为O($n$)

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        key_value = {
     }  # 新建一个字典
        for i in range(len(nums)):  # 开始循环遍历
            other_key = target - nums[i]  # 找到和为target的另一个数字
            if other_key in key_value.keys():  # 如果这个数字键值在字典中
                return [key_value[other_key], i] # 返回两个数字的索引地址
            else:  # 如果这个数字键值不在字典当中
                key_value[nums[i]] = i  # 则将i设为索引, 索引i对应的值存入到字典中

二：有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 2:
输入: “()[]{}”
输出: true

1. 利用栈结构来求解: 首先循环遍历所有的括号，如果遇到的是左括号的放入栈中，遇到右括号的话则与上一个放置栈中的左括号匹配，如果匹配成功，则将栈中的左括号弹出，继续往下匹配；如果匹配不成功，则返回错误,核心是当前循环遍历到的括号与弹出来的括号是否匹配，而且之后栈中还有没有元素!

class Solution:
    def isValid(self, s: str) -> bool: 
        if len(s) == 0:  # 如果括号序列列表长度为0
            return True  # 返回真
        Stack = []  # 栈列表用来存放左括号
        for i in s:  # 循环遍历s中的每一个括号
            if i == '(' or i == '{' or i == '[':
                Stack.append(i)
            else:
                if len(Stack) == 0:  # 如果栈是空，说明此时右括号没有能与之匹配的
                    return False  # 返回错误
                else:
                    temp = Stack.pop()  # 将栈顶元素弹出
                    if i == ')':
                        if temp != '(':  # 如果不匹配')'
                            return False
                    elif i == '}':
                        if temp != '{':  # 如果不匹配'}'![在这里插入图片描述](https://img-blog.csdnimg.cn/20210122205554724.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h0cmVhbGx5ZGFuY2U=,size_16,color_FFFFFF,t_70#pic_center)

                            return False 
                    elif i == ']':  # 如果不匹配']'
                        if temp != '[':
                            return False
        # 循环结束后，如果栈中还有元素，说明还有左括号没有被匹配到
        return True if len(Stack) == 0 else False

执行结果如下（提交成功）:

三：括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合
示例 1：
输出：["((()))","(()())","(())()","()(())","()()()"]

• 利用递归思想实现: 在小夜斗看来，这个题其实就相当一个排列组合问题，将括号按不同方式组合，最终从中选出有效组合！
• 最基本要排除的情况: 第一个括号不能是右括号吧
• 其次括号数量问题: 在遍历循环过程中，左括号数量大于等于右括号
• 最后循环结束: 如果左右括号数量相等并且等于n，就算有效

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        result = []  # 存放有效组合的列表
        # 递归开始的地方，左右括号数码设置为0, 且s设置为空字符
        self.backtracking(n, result, 0, 0, "")
        return result # 返回有效组合的列表结果

    def backtracking(self, n, result, left, right, s):
        # 如果右括号数量大于左括号
        if right > left:
            return  # 直接结束

        # 如果左右括号数相等且都等于n
        if (left == n) and (right == n):
            result.append(s)  # 将有效组合s加入列表
            return # 结束

        # 如果左括号数小于n
        if left < n :
            # 递归调用, 左括号数加1， 并且添加(字符
            self.backtracking(n, result, left+1, right, s+"(")

        # 如果右括号数小于n
        if right < n:
             # 递归调用, 左括号数加1， 并且添加)字符
             self.backtracking(n, result, left, right, s+")")

但是很不幸，上述递归方式提交失败，力扣上显示的报错是内存不够！
然后小夜斗又去查了查资料, 发现了另一种方法!

• 深度优先遍历(dfs)：首先想象一颗隐形的树，n表示左右括号的数目，每生成一颗左子树，则左括号数目减1，新生成的节点加"("，生成一颗右子树，那么右括号数目减1，新生成的节点加")"！
• 直到左右剩余括号数量为0
• 不能向右生成子树的条件: 左括号的剩余数量大于右括号的剩余数量

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        
        result = []  # 存放有效组合的列表
        dict_str = ''  # 用于拼接每一个括号的字符串

        def dfs(dict_str, left, right):
            # dict_str 括号字符串
            # left 左括号剩余数量
            # right 右括号剩余数量
        
            # 左右括号剩余数量都为0
            if left == 0 and right == 0 :  
                result.append(dict_str)  # 将该有效字符串添加到列表
                return 

             # 如果右括号剩余数量少一些
            if right < left: 
                # 就好比第一次就生成右子树，")"位于字符串最前面
                # 后面肯定无法匹配成功， 则直接结束
                return

            # 左括号有剩
            if left > 0:  
                # 生成左子树，添加一个"(", 左括号数量减1
                dfs(dict_str + "(", left-1, right )
          
            # 右括号有剩
            if right > 0: 
            # 生成右子树，添加一个")", 右括号数量减1
                dfs(dict_str + ")", left, right -1 )
        
        # 递归开始，左右括号剩余数量等于n
        dfs(dict_str, n, n)
        # 结束返回结果
        return result

这次小夜斗成功提交啦！

喜欢的小伙伴可以点个赞或者关注一下哈，leedcode学习路上小夜斗和大家一起砥砺前行！当然有学python的小伙伴也可以看看小夜斗以前的python爬虫文章和笔记哈！然后这个系列我是看**Leetcode力扣 1-300题视频讲解合集**的视频学的，喜欢的小伙伴可以去b站观看，讲的真的好!不知道记笔记算原创还是转载还是翻译，就投转载了吧，码字不易，还请多多包涵！

• 在这个星球上，你很重要，请珍惜你的珍贵! ~~~夜斗小神社