Leetcode基础算法结构-目录结构

1、字符串

【知识点】

 1、 for read, c in enumerate(chars): enumerate函数可以对列表索引进行，索引和值得遍历

2、

【题库】

【LeetCode-python 7.整数反转】

【LeetCode-python 14.最长公共前缀】

LeetCode-python 13.罗马数字转整数

 

3.无重复字符的最长子串

 

443. 压缩字符串

 

 

 

2、队列

【知识点】

【题库】

3、

【知识点】

【题库】

4、链表

【知识点】

【题库】

 

5、哈希表

【知识点】

【题库】

LeetCode-python 1.两数之和

 

6、二叉树

【知识点】

【题库】

LeetCode-python 101.对称二叉树

 

 

 

 

 

 

 

 

 

 

 

 

 

Leetcode常用算法框架结构：

 

1、BFS 广度优先遍历，主要解决开始到结束的最短路径问题，begin到target的目标的路径

首先，你要说 labuladong 没写过 BFS 框架，这话没错，今天写个框架你背住就完事儿了。但要是说没写过 DFS 框架，那你还真是说错了，其实 DFS 算法就是回溯算法，我们前文 回溯算法框架套路详解 就写过了，而且写得不是一般得好，建议好好复习。

BFS 的核心思想应该不难理解的，就是把一些问题抽象成图，从一个点开始，向四周开始扩散。一般来说，我们写 BFS 算法都是用「队列」这种数据结构，每次将一个节点周围的所有节点加入队列。

BFS 相对 DFS 的最主要的区别是：BFS 找到的路径一定是最短的，但代价就是空间复杂度比 DFS 大很多，至于为什么，我们后面介绍了框架就很容易看出来了。

本文就由浅入深写两道 BFS 的典型题目，分别是「二叉树的最小高度」和「打开密码锁的最少步数」，手把手教你怎么写 BFS 算法。

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

 

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for a binary tree node.

# class TreeNode:

#     def __init__(self, val=0, left=None, right=None):

#         self.val = val

#         self.left = left

#         self.right = right

class Solution:

    def minDepth(self, root: TreeNode) -> int:

        if not root:

            return 0

        deplist = [[root, 1]]

        while deplist:

            newdep = deplist.pop(0)

            depth = newdep[1]

            if not newdep[0].left and not newdep[0].right:

                return depth

            if newdep[0].left:

                deplist.append([newdep[0].left, depth+1])

            if newdep[0].right:

                deplist.append([newdep[0].right, depth+1])

框架：

1、初始化初始节点，这里树的根节点 ，，层次集合元素

2、列表来存储每层的所有的值和深度，组合值，不断出栈

3、判断结束条件，return返回深度，判断特殊元素的限制条件

4、对层遍历都进行记录和深度加一，对层元素进行处理转化到下层，转换层数的条件可以单独设置

 

坑：if 和elif代表条件执行和全后面不执行

 https://leetcode-cn.com/problems/open-the-lock/

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:

        def addlock(num):
            newnum = []
            for k in range(4):
                if num[k] == '9':
                    newnum.append(num[:k]+'0'+num[k+1:])
                else:
                    newnum.append(num[:k]+str(int(num[k])+1)+num[k+1:])
            return newnum

        def downlock(num):
            newnum = []
            for k in range(4):
                if num[k] == '0':
                    newnum.append(num[:k]+'9'+num[k+1:])
                else:
                    newnum.append(num[:k]+str(int(num[k])-1)+num[k+1:])
            return newnum
        
        lastnum = ['0000']
        numset = set([])
        time = 0
        while lastnum:
            
            temp = []
            for key in lastnum:
                if key in deadends or key in numset:
                    continue
                if key == target:
                    return time

                temp += addlock(key)
                temp += downlock(key)
                numset.add(key)
                

            lastnum = temp
            time = time + 1

        return -1
                




            

 

1、DFS 深度优先遍历

 

 

3、滑动窗口：一般处理连续数组 问题

 while true:

      右指针开始走，

      初步满足条件

      while 循环满足条件：

             left指针增加

      不满足的收获得right-left，获取最大值或者最小值

 

 

 

4、双指针，左右双指针一般解决排序后的数组序列，

 

 

5、动态规划：递归操作的变形，一般解决求最值，递归一般从上到下，直到底层结果不断返回，动态规划是自下向上，直接计算

      单独递归，穷举问题暴力求解

      出现很多重复子问题，重复子问题不用单独计算优化算法

      

       

6、回溯算法的决策树，对应DFS算法，递归变形但是算法复杂度很高，一般都是遍历所有元素进行决策，与动态规划里重叠子问题可以优化时间

result = []
def backtrack(路径, 选择列表):
if 满足结束条件:
result.add(路径)
return

for 选择 in 选择列表:
做选择
backtrack(路径, 选择列表)
撤销选择