小米不同职级薪资待遇一览表

大家好，我是苍何。

之前发了阿里、京东、华为OD 的薪资待遇一览表，后台很多小伙伴留言说，想看看小米的职级薪资待遇。

这就来安排。

小米的职级是从 13 到 22 级，一共有 10 级，对应的职位从专员到经理、主管、总监，最高的是 CXO。

相对比于之前的高级工程师、技术专家等响亮的名字，现在这几年新出的职级虽然普普通通，但却比较好区分。

1、13 级对应的是专员职位，工作年限为 1 年，base 薪资是 22.4 万，加上年终奖 3.2 万，年总包大概在 25.6 万左右。

2、14 级同样是专员职位，通常工作年限为 2 年以上，base 薪资为 23.8 万，年终奖 3.4 万，总包大概在 27.2 万左右。

3、15 级的工作年限为 5 年，base 薪资提升到 34.5 万，年终奖 4.8 万，股权激励 1.3 万，总包可以达到 40.6 万。

4、16 级是专家/经理/主管职位，工作年限 5 年以上，base 薪资为 46 万，年终奖 7.6 万，股权激励 9 万，总包可以达到 62.6 万。

5、17 级也是专家/经理/主管职位，工作年限 10 年，base 薪资为 56 万，年终奖未给出，股权激励 20 万，总包大约是 76 万。

6、18 级为高级经理，工作年限 10 年，base 薪资为 60 万，年终奖 15 万，股权激励 60 万，总包达到 135 万。

7、19 级是总监职位，工作年限为 10 年以上，base 薪资为 135 万，年终奖未给出，股权激励 117 万，总包大约是 252 万。

8、20、21、22 级是超级大佬职位，相关薪资、年终奖、股权激励就未知了。

另外大家会不会好奇雷军的职级？不好意思，雷军没有职级😂

小米是在港股上市的上市公司，以前是 16 级之后才有股权激励，现在优秀的 15 级也开始有一定的激励了。

我对雷军和小米是很佩服的，即使烧了很多钱造小米 SU7，但今年上半年的营业收入还有 1643.95 亿元，同比增长 29.62%。其中净利润增长 17.86%。

看来依旧有很强的赚钱能力，另外雷总今年直接宣布，今年再招 5000 应届生，兼职就是就业市场的一盏亮灯。

对于想冲刺小米的小伙伴，趁着秋招还没结束，赶紧投递起来吧。小米各种福利待遇以及体验都还不错。

好啦，关于小米职级岗位薪资，你有什么看法？你会考虑加入小米集团吗？欢迎评论区讨论。

…

回归主题。

今天来一道小米开发考过的一道面试算法题，给枯燥的牛马生活加加油😂。

• 《RocketMQ 从入门到精通》 原创电子书免费下载（面试必背）
• 面试官看了就喜欢的简历模板免费下载！
• PmHub-开源项目-助你拿个好 offer。

题目描述

平台：LeetCode

题号：155

题目名称：最小栈

设计一个支持 push, pop, top, 和 getMin 操作，且能够在常数时间内检索到最小元素的栈。

实现 MinStack 类：

• MinStack() 初始化堆栈对象。
• void push(int val) 将元素 val 推入堆栈。
• void pop() 删除堆栈顶部的元素。
• int top() 获取堆栈顶部的元素。
• int getMin() 检索堆栈中的最小元素。

示例 1：

输入:

["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出:

[null,null,null,null,-3,null,0,-2]

解释:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   // 返回 -3.
minStack.pop();
minStack.top();      // 返回 0.
minStack.getMin();   // 返回 -2.

提示：

• -2^31 <= val <= 2^31 - 1
• pop, top 和 getMin 操作总是在 非空栈 上调用。
• push, pop, top, 和 getMin 最多被调用 3 * 10^4 次。

解题思路

为了设计一个支持常数时间获取最小值的栈，我们可以使用辅助栈来保存最小值。

具体思路如下：

1. 使用两个栈，一个主栈 stack 保存所有元素，另一个最小栈 minStack 保存当前的最小元素。
2. 在每次 push 操作时，除了将值压入主栈外，如果最小栈为空或当前压入的值小于等于最小栈的栈顶元素，则将该值也压入最小栈。
3. 在 pop 操作时，若主栈弹出的元素与最小栈栈顶元素相等，则同时弹出最小栈的栈顶元素，保证最小栈始终保存当前最小值。
4. 在 top 操作时，直接返回主栈栈顶元素。
5. 在 getMin 操作时，直接返回最小栈栈顶元素，即为当前栈中的最小值。

通过这样的设计，所有操作的时间复杂度均为 O (1)。

代码实现

Java 代码：

import java.util.Stack;

class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }

    public void push(int val) {
        stack.push(val);
        // 如果minStack为空，或者val小于等于minStack的栈顶元素，压入minStack
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }

    public void pop() {
        // 弹出栈顶元素，并且如果该元素是当前最小值，也从minStack弹出
        if (stack.pop().equals(minStack.peek())) {
            minStack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return minStack.peek();
    }
}

C++代码：

#include <stack>

class MinStack {
private:
    std::stack<int> stack;
    std::stack<int> minStack;

public:
    MinStack() {}

    void push(int val) {
        stack.push(val);
        // 如果minStack为空或者当前元素不大于minStack的栈顶，压入minStack
        if (minStack.empty() || val <= minStack.top()) {
            minStack.push(val);
        }
    }

    void pop() {
        // 弹出主栈栈顶元素，如果等于最小栈栈顶元素，最小栈也要弹出
        if (stack.top() == minStack.top()) {
            minStack.pop();
        }
        stack.pop();
    }

    int top() {
        return stack.top();
    }

    int getMin() {
        return minStack.top();
    }
};

Python 代码：

class MinStack:

    def __init__(self):
        self.stack = []
        self.minStack = []

    def push(self, val: int) -> None:
        self.stack.append(val)
        # 如果minStack为空或者val小于等于minStack的栈顶，压入minStack
        if not self.minStack or val <= self.minStack[-1]:
            self.minStack.append(val)

    def pop(self) -> None:
        # 如果栈顶元素等于minStack栈顶，则minStack也弹出
        if self.stack.pop() == self.minStack[-1]:
            self.minStack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.minStack[-1]

复杂度分析

• 时间复杂度：所有操作 push, pop, top, getMin 都是 O (1)，因为辅助栈的操作与主栈是同步的。
• 空间复杂度：O (n)，其中 n 是元素的数量。我们使用了两个栈来存储数据，空间使用与输入元素数量线性相关。

ending

你好呀，我是苍何。是一个每天都在给自家仙人掌讲哲学的执着青年，我活在世上，无非想要明白些道理，遇见些有趣的事。倘能如我所愿，我的一生就算成功。共勉 💪

点击关注下方账号，你将感受到一个朋克的灵魂，且每篇文章都有惊喜。

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