算法刷题总结

万物皆有模板，所有的算法题也一样。牢记模板，让你刷题事半功倍！

1. 回溯法

　　大致流程如下，万变不离其宗！

def backtrack(nums): ---> nums[[]]
    # 这里可以添加一些边界条件，直接return []
    res = []
    
    # 定义回溯主体
    def helper(num, tmp):
        # 当num为空时，收录结果
        if not num:
            res.append(tmp)
            return
        # 构造循环条件
        for i in range(len(num)):      
            if xxxxxxxx:   # 需满足回溯条件才进入
                helper(num[i+1], tmp+ [num[i]]) #举例子
    helper(nums, [])
    return res

 2. bfs

最短路径bfs的代码模板

def bfs(root, target):
    que = []
    step = 0
    # initialize
    add root to queue
    # BFS
    while queue:
        step += 1
        // iterate the nodes which are already in the queue
        for i in range(len(queue)):
            cur = first node in queue
            return step if cur is target
            for node in cur.neighbors:
                add node to queue   # 当图中有环时，可以另外设置一个visited列表存储已经访问过的node，防止陷入循环
            remove the first node from queue
      return -1

 3. 二叉树遍历

def preoder(node):
　　if not node:
　　　　return []
　　stk = [root]
　　ans = []
　　while stk:
　　　　p = stk.pop()
　　　　ans.append(p.val)
　　　　if p.right:
　　　　　　stk.append(p.right)
　　　　if p.left:
　　　　　　stk.append(p.left)
　　return ans

def postorder(node):
　　if not node:
　　　　return []
　　stk = [root]
　　ans = []
　　while stk:
　　　　p = stk.pop()
　　　　ans.append(p.val)
　　　　if p.left:
　　　　　　stk.append(p.left)
　　　　if p.right:
　　　　　　stk.append(p.right)
　　return ans[::-1]

def midorder(node):
　　if not node:
　　　　return []
　　p = node
　　ans = []
　　stk = []
　　while stk or p:
　　　　while p:
　　　　　　stk.append(p)
　　　　　　p = p.left
　　　　p = stk.pop()
　　　　ans.append(p.val)
　　　　if p.right:
　　　　　　p = p.right
　　return ans

 3. 旋转矩阵的trick

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        # 水平翻转
        for i in range(n // 2):
            for j in range(n):
                matrix[i][j], matrix[n - i - 1][j] = matrix[n - i - 1][j], matrix[i][j]
        # 主对角线翻转
        for i in range(n):
            for j in range(i):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

class Solution:
　　def rotate(self, matrix):
　　　　"""
　　　　:type matrix: List[List[int]]
　　　　:rtype: void Do not return anything, modify matrix in-place instead.
　　　　"""
　　　　n = len(matrix[0])
　　　　# transpose matrix
　　　　for i in range(n):
　　　　　　for j in range(i, n):
　　　　　　　　matrix[j][i], matrix[i][j] = matrix[i][j], matrix[j][i]

　　　　# reverse each row
　　　　for i in range(n):
　　　　　　matrix[i].reverse()