神仙公司名单（苏州）

神仙公司（苏州）

前几天虽辟谣了 苏州佳能 N+12/2N+12 的裁员赔偿，但也同时指出了苏州是外企偏多，就业环境和生活节奏平衡的好城市。

但提到苏州公司，大家第一印象是微软、思科 和 Zoom 此类以 WLB 闻名的明星企业。

确实，如果你在国内大厂待得比较久，那么此类公司可以一句话总结：不是你想象中的舒服，是你想象不到的舒服。

但除这些明星企业以外，苏州还有不少“相对小众”的神仙公司，今天就来跟大家分享一下：

• 松下：除常规假期以外，还有「育儿假」和「家庭抚养假」，15 薪 + 绩效 + 年终奖
• 科思创：公司文化倡导 WLB（工作与生活平衡），每年普涨，15 天年假，逢年过节有礼物，有生育津贴和购房补贴，公司有专门的母婴室和女性休息室，14 薪 + 年终奖
• 恩智浦：弹性办公，965，有班车、租房补贴、健身房、学费报销和医疗保险，13 薪 + 绩效 + 期权
• 博世：965，节日礼物，15 天年假 + 10 天带薪病假，每年外出旅行一次，全额缴纳五险一金（额外给员工购买商业险），公积金比例 12%，13 薪 + 高额奖金

以上都是坐标苏州，有计算机相关在招岗位的企业，大家有兴趣可以留意一下。

...

回归主题。

周末了，来一道不难的算法题。

题目描述

平台：LeetCode

题号：199

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]

输出: [1,3,4]

示例 2:

输入: [1,null,3]

输出: [1,3]

示例 3:

输入: []

输出: []

提示:

• 二叉树的节点个数的范围是

BFS

本质就是找层序遍历过程中，每层的最后一个节点。

Java 代码：

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) return ans;
        Deque<TreeNode> d = new ArrayDeque<>();
        d.addLast(root);
        while (!d.isEmpty()) {
            int sz = d.size();
            while (sz-- > 0) {
                TreeNode node = d.pollFirst();
                if (node.left != null) d.addLast(node.left);
                if (node.right != null) d.addLast(node.right);
                if (sz == 0) ans.add(node.val);
            }
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ans;
        if (!root) return ans;
        queue<TreeNode*> d;
        d.push(root);
        while (!d.empty()) {
            int sz = d.size();
            while (sz-- > 0) {
                TreeNode* node = d.front();
                d.pop();
                if (node->left) d.push(node->left);
                if (node->right) d.push(node->right);
                if (sz == 0) ans.push_back(node->val);
            }
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        if not root:
            return ans
        d = deque()
        d.append(root)
        while d:
            sz = len(d)
            while sz > 0:
                node = d.popleft()
                if node.left:
                    d.append(node.left)
                if node.right:
                    d.append(node.right)
                if sz == 1:
                    ans.append(node.val)
                sz -= 1
        return ans

TypeScript 代码：

function rightSideView(root: TreeNode | null): number[] {
    const ans = [];
    if (!root) return ans;
    const d = [];
    d.push(root);
    while (d.length > 0) {
        let sz = d.length;
        while (sz-- > 0) {
            const node = d.shift()!;
            if (node.left) d.push(node.left);
            if (node.right) d.push(node.right);
            if (sz === 0) ans.push(node.val);
        }
    }
    return ans;
};

• 时间复杂度：
• 空间复杂度：

DFS

DFS 解法同理，规定好节点的遍历顺序（例如 中-右-左），并在 DFS 过程中传递当前层参数 level（根节点为第 0 层），同时使用一个 Set 数据结构记录处理过的层编号，从而实现只将当前层的首个节点添加到答案中。

Java 代码：

class Solution {
    List<Integer> ans = new ArrayList<>();
    Set<Integer> set = new HashSet<>();
    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0);
        return ans;
    }
    void dfs(TreeNode node, int level) {
        if (node == null) return ;
        if (!set.contains(level)) {
            ans.add(node.val);
            set.add(level);
        }
        dfs(node.right, level + 1);
        dfs(node.left, level + 1);
    }
}

C++ 代码：

class Solution {
public:
    vector<int> ans;
    unordered_set<int> levels;
    vector<int> rightSideView(TreeNode* root) {
        dfs(root, 0);
        return ans;
    }
    void dfs(TreeNode* node, int level) {
        if (!node) return;
        if (levels.find(level) == levels.end()) {
            ans.push_back(node->val);
            levels.insert(level);
        }
        dfs(node->right, level + 1);
        dfs(node->left, level + 1);
    }
};

Python 代码：

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:        
        def dfs(node, level):
            if not node:
                return
            if level not in levels:
                ans.append(node.val)
                levels.add(level)
            dfs(node.right, level + 1)
            dfs(node.left, level + 1)
        ans = []
        levels = set()
        dfs(root, 0)
        return ans

TypeScript 代码：

function rightSideView(root: TreeNode | null): number[] {
    const ans = [];
    const levels = new Set();
    function dfs(node: TreeNode | null, level: number) {
        if (!node) return;
        if (!levels.has(level)) {
            ans.push(node.val);
            levels.add(level);
        }
        dfs(node.right, level + 1);
        dfs(node.left, level + 1);
    }
    dfs(root, 0);
    return ans;
};

• 时间复杂度：
• 空间复杂度：

最后

巨划算的 LeetCode 会员优惠通道目前仍可用 ~

使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。

我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉