KaelCui的博客

103. 二叉树的锯齿形层序遍历# 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 = rightclass Solution: def zigzagLevelOrder(self,

523. 连续的子数组和class Solution: def checkSubarraySum(self, nums: List[int], k: int) -> bool: if k == 0: return any(nums[i] == 0 and nums[i+1] == 0 for i in range(len(nums) - 1)) mods, cum_sum_mod_k = {0:-1}, 0 for i

5685. 交替合并字符串class Solution: def mergeAlternately(self, word1: str, word2: str) -> str: n1, n2 = map(len, (word1, word2)) i, j = 0, 0 res = '' while i < n1 and j < n2: res += word1[i] r

709. 转换成小写字母class Solution: def toLowerCase(self, str: str) -> str: return ''.join(chr(ord(c) + 32) if 'A' <= c <= 'Z' else c for c in str)58. 最后一个单词的长度class Solution: def lengthOfLastWord(self, s: str) -> int: retur

198. 打家劫舍股票买卖问题121. 买卖股票的最佳时机

复习：

1122. 数组的相对排序class Solution: def relativeSortArray(self, arr1: List[int], arr2: List[int]) -> List[int]: dic = {b:i for i, b in enumerate(arr2)} return sorted(arr1, key = lambda a:dic.get(a, a + 1000))242. 有效的字母异位词**字母异位词：**即为各个字

146. LRU 缓存机制

布隆过滤器LRUCache

191. 位1的个数class Solution: def hammingWeight(self, n: int) -> int: # 方法1:这个题目华为机试题出现过 # return bin(n).count('1') # 方法二：使用位运算的方法 cnt = 0 while n: n &= n - 1 # 清零最低位的1 cnt += 1

1091. 二进制矩阵中的最短路径每一层八个方向，先BFS之后，然后访问的（非0非1的元素）不再被访问视频题解class Solution: def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int: n = len(grid) if grid[0][0] or grid[n-1][n-1]: # 如果（0,0）或（n-1, n-1）为1，按照题解，直接返回 -1

200. 岛屿数量# 这里的方法是并查集class Solution(object): def numIslands(self, grid): if not grid: return 0 row, col = map(len, (grid, grid[0])) id = [i for i in range(row * col)] self.count = sum([grid[i][j] == '1' for

添加链接描述效果如下图所示：意思是在找 d 的parent的时候，不仅找到了a, 并且把沿路上走过的点的parent指向a, 这样下次在找 c, d 的parent的时候直接是O(1)的算法复杂度最后的话是要看下孤立的群里面有几个，就是有几个朋友圈200. 岛屿数量# 这里是采用并查集的方法做的class Solution(object): def numIslands(self, grid): if not grid: return 0 row

208. 实现 Trie (前缀树)class Trie: def __init__(self): """ Initialize your data structure here. """ self.root = {} self.end_of_word = '#' def insert(self, word: str) -> None: """ Inserts a wo

32. 最长有效括号视频题解class Solution(object): def longestValidParentheses(self, s): dp = [0 for x in range(len(s))] max_to_now = 0 for i in range(1,len(s)): if s[i] == ')': # case 1: ()() i

69. x 的平方根class Solution: def mySqrt(self, x: int) -> int: # return int(x ** 0.5) # 直接用牛顿迭代法 r = x while r * r > x: r = (r + x/r) // 2 return int(r)367. 有效的完全平方数class Solution: def isPer

62. 不同路径class Solution: def uniquePaths(self, m: int, n: int) -> int: aux = [[1 for x in range(n)] for x in range(m)] # 他这里是将所有的元素都初始话为1的 for i in range(1, m): for j in range(1, n): aux[i][j]

动态规划 = 分治+最优子结构所以动态规划不需要保留所有的状态，只需要保留最优的状态就可以了关键点：动态规划和递归或者分治没有根本上的区别（关键看有无最优的子结构）共性：找到重复的值子问题差异性：最优子结构、中途可以淘汰次优解...

二分查找的前提：目标函数单调性（单调递增或者单调递减）存在上下界能够通过索引访问P.S:如果是无序的，只能是所有元素都遍历一遍代码模板left, right = 0, len(array) - 1while left <= right: mid = (left + right) / 2 if array[mid] == target: # 找到目标变量 break or return result elif array[mid] < targ

这里是贪心的定义和贪心和动态规划的区别：一旦一个问题可以通过贪心法来解决，那么贪心法一般是解决这个问题的最好办法。

322. 零钱兑换class Solution: def coinChange(self, coins: List[int], amount: int) -> int: dp = [float('inf')] * (amount + 1) dp[0] = 0 for i in range(1, amount + 1): for j in range(len(coins)):

102. 二叉树的层序遍历def levelOrder(self, root): ans, level = [], [root] while root and level: ans.append([node.val for node in level]) level = [kid for n in level for kid in (n.left, n.right) if kid] return ans433. 最小基因变

410. 分割数组的最大值class Solution: def splitArray(self, nums: List[int], m: int) -> int: ''' 二分法 时间复杂度：(N log Sum) 空间复杂度：O(1) ''' left , right = max(nums), sum(nums) while left < right:

深度优先搜索Depth-First-Search搜索-遍历每个节点都要访问一次每个节点仅仅访问一次对于节点的访问顺序不限深度优先：depth first search广度优先 :breadth first searchDFS 代码 - 递归写法visited = set()def dfs(node, visited): if node in visited: # terminator # already visited return visited.add(node)

50 Pow(x, n) （Facebook 在半年内面试常考）思路Base Case: n == 0Function: F(x ^ n) = F(x ^ (n // 2)) * F(x ^ (n // 2))不论我们返回时候如何，我们执行第一步，先设立Base Case:if n == 0: return 1完了以后，我们要对大问题进行拆分，也就是不断的对b的值折半拆分：half = self.myPow(x, n // 2)当拆分到了最小的问题，满足base case n ==

70. 爬楼梯（阿里巴巴、腾讯、字节跳动在半年内面试常考）# 方法一：数学法class Solution: def climbStairs(self, n: int) -> int: sqrt5 = sqrt(5) fib = pow((1 + sqrt5)/2, n + 1) - pow((1 - sqrt5)/2,n + 1) return int(fib / sqrt5)# 方法二：加了缓存的递归class Solution:

242.有效的字母异位词（亚马逊、Facebook、谷歌在半年内面试中考过）class Solution: def isAnagram(self, s: str, t: str) -> bool: return collections.Counter(s) == collections.Counter(t)49.字母异位词分组（亚马逊在半年内面试中常考）class Solution: def groupAnagrams(self, strs: List[str]

1.图的属性和分类本部分图的内容，面试的时候应该根据被面试公司的情况看是否需要准备更多内容，文末有相关学习链接图的属性Graph(V, E):图是点和边的集合构成的V -vertex:点度：入度和出度点与点之间：连通与否E - edge:边有向和无向（单行线）权重（边长)图的表示和分类图的表示方法有两种，分别是：邻接矩阵：有相邻的边加权重，没有的话如果有边加1，没有边的化加 0如果是有向图的话，其邻接矩阵是对称矩阵邻接表：用链表来存储和点相连

1.堆 Heap定义：可以迅速找到一堆数中的最大值或者最小值的数据结构。应用场景：经常是一个数一个数的过来，比如找最大值或者找最小值分类：堆本身是一个抽象的数据结构，根据实现形式，将其分为二叉堆、斐波那契堆等。P.S: 二叉堆是堆（优先队列 priority_queue) 的一种常见且简单的实现，但是并不是最优的实现形式，但是在面试的时候以及教科书上出现比较多。真正在工程中使用的是 严格斐波那契堆等性能优异的堆，面试的时候知道有这么一种堆就行，暂时没必要知道怎么实现的。参考将根节点最大的堆叫做

94. 二叉树的中序遍历（亚马逊、微软、字节跳动在半年内面试中考过）为什么有人说写的递归程序效率不高，这个不是递归的原因，是因为自己的逻辑问题，比如斐波那契数列那道题就是因为递归没有加缓存保留之前的状态，导致写出来的递归程序效率很低，在写树的相关程序的时候我们要“爱上递归，拥抱递归‘# 方法一：recursivelyclass Solution: def inorderTraversal(self, root: TreeNode) -> List[int]: res =

26. 删除排序数组中的重复项 class Solution: def removeDuplicates(self,nums：List[int])->int: # 双指针 i = 0 for j in range(len(nums)): if nums[i] != nums[j]: i += 1 nums[i] = nums[j] ret.

Online Judge 与算法的特点牛客网的是标准的输入输出，leetcode 是写的函数，面试之前要两者都进行训练贪心的题目尝试证明------->可以用贪心找反证--------->证明不可以用贪心如果没有别的做法，就相信他是贪心，接下来就多加练习题面破解：题面出现 ’最‘ 或者等价的字可能是贪心贪心的题目一定有 ’ 最‘ 字贪心往往伴随着排序（因为排序就潜在的定义了 贪心提到的 ’ 好‘ ）1338 数组大小减半class Solution: .

242 有效的字母异位词（亚马逊、Facebook、谷歌在半年内面试中考过）注意切题四件套：clarification 和面试官搞清楚题目的要求，即题面是什么，比如在本题中需要搞清楚，什么是异位词：异位词是字母出现的次数一样，但是出现顺序不一样的词在本题中是否区分大小写？possible solutions—>optimal(time & space)codetest cases这里一定要记得和面试官要几个测试样例，证明你做事是有始有终的本题的方法有：暴力法：

P.S:见到最近相关性的问题，想到用栈见到有先后顺序的时候，或者先来后到的时候用到 queue20 有效括号凡是涉及到最近相关性的可以考虑到用栈解决class Solution: def isValid(self, s: str) -> bool: hashmap = {']':'[','}':'{',')':'('} stack = [] for char in s: if char in hashmap:

学习过数据结构和算法的人一定不会对下面的几张图陌生了，这几张图展示的比较全，希望可以供自己备查，也可以帮助到更多的人目录1.常见的时间复杂度、空间复杂度的类型2.常见数据结构和算法的时间和空间复杂度3.常见的排序算法时间和空间复杂度API 官方文档及源码的快速查询1.常见的时间复杂度、空间复杂度的类型2.常见数据结构和算法的时间和空间复杂度3.常见的排序算法时间和空间复杂度API 官方文档及源码的快速查询比如想查 在 python 里面 stack 的API，在Goole 或者百度上面输入

目录1. stack 栈2. Queue 队列3. Deque 双端队列4.Priority Queue 优先队列1. stack 栈先进后出（FILO），或者叫后进先出(LIIFO)操作复杂度添加O(1)删除O(1)查询O(n)P.S: 因为元素是无序的，所以查询的时间复杂度是 O(n)的2. Queue 队列先进先出（FIFO) ， 后进后出（LILO)操作复杂度添加O(1)删除O(1)查询O(n)3

P.S: 链表类的题目比较简单，但是如果一不小心容易写的特别复杂，需要在面试之前把复杂的链表题目再熟悉一下206 反转链表（字节跳动、亚马逊在半年内面试常考）本题参考题解# 迭代法def reverseList(head): # 申请两个节点 pre 和 cur ,pre 指向 None pre, cur = None, head while cur: cur.next = pre # 然后将当前的节点指向 pre pre = cur

1两数之和（近半年内，字节跳动在面试中考查此题达到 152 次）11盛最多水的容器（腾讯、百度、字节跳动在近半年内面试常考）移动零（华为、字节跳动在近半年内面试常考）爬楼梯（阿里巴巴、腾讯、字节跳动在半年内面试常考）数学法的证明如下：三数之和（国内、国际大厂历年面试高频老题）...