年薪60万华为小领导爆料:在华为是个小领导，带20个外包，天天催他们干活，甚至通宵改 BUG,自己啥都没干，一直摘果子。。

刚看到个贴子，说有网友爆料在华为当“小领导”，年薪60万，带着二十个外包天天催命似的干活，通宵改BUG，他自己基本不碰代码，只负责摘果子，还说心里“过意不去”。

你负责管理，外包负责执行，本质就是岗位价值不同。你觉得“啥都没干”，那可能只是你认为写代码才叫干活，但团队协调、资源对接、背锅扛责这些活，不是活？真出问题时，被钉在公告板上的可不是外包。

不过话说回来，别把“摘果子”当成理所当然，该承担的责任不能躲，该给团队争的资源不能省。职位带来的不是特权，而是义务。

职场不是道德秀场，做好自己的活，带好自己的队，就是最大的负责。【备注:文末可领最新资料】

面试题：翻转二叉树

一般题目会这么写： 给你一棵二叉树，把这棵树“翻转”一下，并返回新的根节点。

“翻转”其实就是： 对树里的每一个节点，都把它的左孩子和右孩子交换一下。 最后整棵树就好像照了一面镜子，从左变右，从右变左。

先有棵树，长什么样？

我们一般会这样定义一个二叉树节点（题里基本都是这个结构）：

classTreeNode:
def__init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

比如一棵小树：

    4
   / \
  2   7
 / \ / \
1  3 6  9

翻转之后变成：

    4
   / \
  7   2
 / \ / \
9  6 3  1

核心动作只有一个： 对每个节点，把 left 和 right 换一下。

递归思路：一句话就能说完

递归的直觉版思路是：

• 翻转以当前节点为根的树 = 先翻转它的左子树

• 再翻转它的右子树
• 最后把左右子树交换一下

或者再简化一点，人话就是：

“到一个节点这儿，先把它的左右子树都翻好，再把左右指针对调。”

递归出口也很自然： 如果这个节点是空的（None），那就什么也不用做，直接返回。

definvertTree(root: TreeNode) -> TreeNode:
# 1. 空节点，直接返回
if root isNone:
returnNone

# 2. 递归翻转左右子树
    left_inverted = invertTree(root.left)
    right_inverted = invertTree(root.right)

# 3. 交换左右指针
    root.left, root.right = right_inverted, left_inverted

# 4. 返回当前节点作为这一棵子树的新根
return root

你可以注意几个点：

• 每个节点只被访问一次
• 在“回溯”阶段才真正交换左右
• 返回的还是同一棵树，只是指针方向变了

时间和空间复杂度顺带算一下

时间复杂度： 整棵树的每个节点都要看一遍，做一次交换， 所以是 O(n)，n 是节点数量。

空间复杂度： 主要来自递归调用栈，最深的时候会等于树的高度 h。

• 最坏情况（链表那种歪树）：O(n)
• 最好情况（完全平衡）：O(log n)

不想递归？来个迭代写法（队列 BFS）

有时候面试官会顺带问一句：能不能不用递归？ 那我们就用一个队列，从根节点开始一层层处理：

思路也很直白： 每次从队列里拿一个节点，交换它的左右孩子，然后把不为空的孩子继续丢进队列。

from collections import deque

definvertTree_iter(root: TreeNode) -> TreeNode:
if root isNone:
returnNone

    queue = deque([root])

while queue:
        node = queue.popleft()

# 交换当前节点的左右子树
        node.left, node.right = node.right, node.left

# 把左右孩子加入队列，继续处理
if node.left:
            queue.append(node.left)
if node.right:
            queue.append(node.right)

return root

这个版本的时间复杂度还是 O(n)， 空间复杂度来自队列，最坏情况下某一层的节点很多，也是 O(n)。

翻转二叉树其实就是在做一件特别简单的事：

对树里的每个节点，把左右孩子换个位置。

记住两个关键点就够了：

1. 遍历整棵树（递归也好，队列/栈也好），保证每个节点都被处理到
2. 在访问到某个节点时，交换它的 left 和 right

这个题本身不难，但它经常被用来考察你对“树的遍历 + 递归 / 迭代”的理解。 做熟了之后，后面遇到“处理每个节点做点小操作”的树题，套路基本就都通了。