Récord de prácticas en prácticas

Animarse. progreso. Continuamente actualizado.

Puestos previstos: ingeniero de algoritmos, ingeniero de desarrollo, ingeniero de pruebas

Actualización: después de pensarlo, siento que mi tesis todavía tiene capacidad de codificación y la capacidad de innovación es un poco más débil. Puedo centrarme en los ingenieros de desarrollo.

1. Resumen de la experiencia presencial:

5. Entrevista con el ingeniero de desarrollo

Resumen de Autumn Recruitment | Escuchemos mi experiencia de abandonar los algoritmos y pasar al desarrollo en Autumn Recruitment~_头生活_Niuke.com 1. Prefacio Como graduado de la maestría de este año en 2022, participé en una trágica batalla de reclutamiento en otoño. Afortunadamente, luché El resultado no es malo y finalmente firmé un contrato con Beijing Meituan, el puesto es desarrollo de back-end, ahora para resumir el proceso de reclutamiento de otoño y dar retroalimentación a Nioke. Vale la pena señalar aquí que transfirí de la pista del algoritmo al desarrollo

6. Resumen de la entrevista en C++

Antecedentes de C++: resumen desde la pasantía hasta la contratación de otoño (firmado en Tencent WeChat)_Bi Jing Mian Jing_Niuke.com Este es el enlace de mis notas desde la pasantía hasta la contratación de otoño: https://pan.baidu.com/s/1p3K6VILrMexeb8ciCRitdQ Código de extracción: zsu6 Aunque el contenido se debe a mis propias palabras

2. Elaboración de puntos de conocimiento:

Algunos enlaces que valen la pena:

Conocimientos básicos de C++ Encyclopedia_clw_18's Blog-CSDN Blog Autumn Recruitment está básicamente resuelto, y tengo la intención de resumir los conocimientos relevantes de la ruta de aprendizaje de C++.Hoy es el primer artículo: Resumen de conocimientos básicos de C++. Tres características principales de la orientación a objetos: 1. Encapsulación: cosas objetivas abstractas en clases, incluidos sus propios atributos y métodos. 2. Herencia: use todas las funciones de la clase existente para expandir la función de la clase sin reescribir la clase original. La clase heredada se convierte en la clase padre o clase base, y la clase heredada se convierte en la subclase o clase derivada. 3. Polimorfismo: una forma, múltiples estados, divididos en polimorfismo estático y polimorfismo dinámico. El polimorfismo estático se refiere al polimorfismo en tiempo de compilación, como la sobrecarga de funciones y las plantillas; el polimorfismo dinámico se refiere al polimorfismo en tiempo de ejecución, especialmente el polimorfismo formado por el mecanismo de función virtual virtual. Derechos de acceso a clases: privado, protegido https://blog.csdn.net/weixin_49199646/article/details/121066029

3. Códigos de corte comunes:

1. Recorrido de árbol binario

Explicación detallada del recorrido previo al pedido, el recorrido en orden y el recorrido posterior al pedido de árboles

Solución de referencia: botón de fuerza

Estas preguntas tienen una versión recursiva de la solución, similar, la principal dificultad es cómo lograr la recursividad, cómo entender la recursividad:

¿Hay alguna buena manera de entender la recursividad? - saber casi

La solución recursiva es más simple:

prefacio

# 方法一 递归解法 前序后序中序都是相同的套路
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        def preorder(root: TreeNode):
            # 结束条件：节点为null,则结束
            if not root:
                return
            # 遍历根节点
            res.append(root.val)
            # 遍历
            preorder(root.left)
            preorder(root.right)
        res = list()
        preorder(root)
        return res
# 时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次
# 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为 O(\log n)，最坏情况下树呈现链状，为 O(n)。

En secuencia

# 方法一 递归法
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        def inorder(root: TreeNode):
            if not root:
                return
            # 先遍历左子树
            inorder(root.left)
            # 根节点
            res.append(root.val)
            # 遍历右子树
            inorder(root.right)
        res = list()
        inorder(root)
        return res

Subsecuente

# 解法一 递归法
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        def postorder(root:TreeNode):
            if not root:
                return
            postorder(root.left)
            postorder(root.right)
            res.append(root.val)
        res = list()
        postorder(root)
        return res

Solución iterativa:

Una pila se mantiene implícitamente durante la recursividad y esta pila debe simularse explícitamente durante la iteración. Esta dificultad es un poco más difícil que la recursividad.

prólogo:

# 方法二 迭代解法
# 使用栈来递归
# https://www.bilibili.com/video/BV1dA411L7Mj  这个up讲得太好了！！！一下子明白了
# 1. 初始化栈，将根节点入栈
# 2. 当栈不为空时：
# 弹出栈顶元素 node，并将值添加到结果中；
# 如果 node 的右子树非空，将右子树入栈；
# 如果 node 的左子树非空，将左子树入栈

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 特例判断
        if not root:
            return
        # 把根节点压入栈中
        stack = [root]
        # 结果列表
        ans = []
        # 当栈不为空，也就是树还没遍历完
        while stack:
            # 弹出栈顶元素
            node = stack.pop()
            ans.append(node.val)
            # 先把右子树压进去，先进后出
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return ans

En secuencia

# 方法二 迭代法 使用一个固定的模板
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        ans = []
        # 都是要先把根节点压进去
        cur, stack = root, []
        # 只要当前节点或者栈有一个不是空就继续遍历
        while cur or stack:
            while cur:
                # cur 入栈
                stack.append(cur)
                # 找到当前最左端的孩子
                cur = cur.left
            # 弹出栈顶元素
            tmp = stack.pop()
            # 加入结果
            ans.append(tmp.val)
            # 弹出栈中叶节点的父节点，当左子树完全遍历完就会遍历右子树
            cur = tmp.right

No entiendo el orden posterior y necesito un nodo previo para juzgar si debo atravesarlo. ?