字节员工：18年入职，攒了8400股，价值900多万。。。-CSDN博客

本文链接：https://blog.csdn.net/abcdef314159/article/details/135639466

最近一字节员工在网上发帖，说自己18年入职到现在一股没卖过，辛辛苦苦攒了8400股。按照字节跳动第二轮员工期权回购计算，离职员工税前回购价格为 128 美元 / 股，在职员工为 160 美元 / 股，他应该是在职，总的金额是134.4万美元，折合人民币900多万。

一网友直接回复：千万富翁。不得不说有时候选对公司真的很重要，很多人一辈子都挣不了900多万，有的人轻轻松松几年就挣到了。

有的网友说：还得是大厂，直接财富自由了。其实财富自由倒不至于，在一线城市买套房还是没问题的（别买10万/平以上了，买个小两房还是足够的）。

还有的说当时给了8000股最后没去。

还有网友直接说：好羡慕。

--------------下面是今天的算法题--------------

看完了字节员工的收入，我们来看一道字节的面试题，这题是LeetCode的第150题：逆波兰表达式求值。一网友在字节面试的时候遇到过这道题。

问题描述

来源：LeetCode第150题

难度：中等

给你一个字符串数组 tokens ，表示一个根据逆波兰表示法表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。

示例1：

输入：tokens = ["2","1","+","3","*"]

输出：9

解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例2：

输入：tokens = ["4","13","5","/","+"]

输出：6

解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

1 <= tokens.length <= 10^4
tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

问题分析

这题是逆波兰表达式求值，非常简单的一道题。我们平时书写的表达式是中缀表达式，运算符在中间，操作数在两边，比如a+b。逆波兰表达式是后缀表达式，操作数在前，运算符在后，比如 a b + 。还有一个是前缀表达式，也是波兰表达式，是运算符在前，操作数在后，比如 + a b 。

对于我们人来说中缀表达式是最容易计算的，但对于计算机来说更容易计算的是前缀表达式和后缀表达式。关于前，中，后三种表达式的相互转换有堆栈法，二叉树法和括号法，具体可以看下算法秘籍中的第十三章。

对于逆波兰表达式的计算我们只需要使用一个栈即可，遍历字符串数组，如果遇到数字就入栈，如果是运算符就从栈中弹出两个数字，先出栈的是右值，后出栈的是左值，他们计算的结果也要入栈。

JAVA：

public int evalRPN(String[] tokens) {
    Stack<Integer> stack = new Stack<>();
    int num1, num2;
    for (String token : tokens) {
        if (isSignal(token)) {
            // 如果是运算符，就从栈中连续弹出两个数字。
            num1 = stack.pop();// 右值
            num2 = stack.pop();// 左值
            if (token.equals("+")) {//加法
                stack.push(num2 + num1);
            } else if (token.equals("-")) {//减法
                stack.push(num2 - num1);
            } else if (token.equals("*")) {//乘法
                stack.push(num2 * num1);
            } else if (token.equals("/")) {//除法
                stack.push(num2 / num1);
            }
        } else { // 如果是数字，就把他压入到栈中
            stack.push(Integer.parseInt(token));
        }
    }
    // 最后栈中只有一个元素，取出即可
    return stack.pop();
}

// 判断是否是符号
private boolean isSignal(String token) {
    return "+".equals(token) || "-".equals(token)
            || "*".equals(token) || "/".equals(token);
}

C++：

public:
    int evalRPN(vector<string> &tokens) {
        stack<int> stk;
        int num1, num2;
        for (string &token: tokens) {
            if (isSignal(token)) {
                // 如果是运算符，就从栈中连续弹出两个数字。
                num1 = stk.top();// 右值
                stk.pop();
                num2 = stk.top();// 左值
                stk.pop();
                if (token[0] == '+')//加法
                    stk.push(num2 + num1);
                else if (token[0] == '-') {//减法
                    stk.push(num2 - num1);
                } else if (token[0] == '*') {//乘法
                    stk.push(num2 * num1);
                } else if (token[0] == '/') {//除法
                    stk.push(num2 / num1);
                }
            } else {// 如果是数字，就把他压入到栈中
                stk.push(stoi(token));
            }
        }
        // 最后栈中只有一个元素，取出即可
        return stk.top();
    }

    // 判断是否是符号
    bool isSignal(string &token) {
        return "+" == token || "-" == token
               || "*" == token || "/" == token;
    }

C：

// 判断是否是符号
bool isSignal(char *token) {
    return strlen(token) == 1 && !(token[0] >= '0' && token[0] <= '9');
}

int evalRPN(char **tokens, int tokensSize) {
    int stk[tokensSize], top = 0;
    int num1, num2;
    for (int i = 0; i < tokensSize; i++) {
        char *token = tokens[i];
        if (isSignal(token)) {
            num1 = stk[--top];// 右值
            num2 = stk[--top];// 左值
            if (token[0] == '+') {//加法
                stk[top++] = num2 + num1;
            } else if (token[0] == '-') {//减法
                stk[top++] = num2 - num1;
            } else if (token[0] == '*') {//乘法
                stk[top++] = num2 * num1;
            } else if (token[0] == '/') {//除法
                stk[top++] = num2 / num1;
            }
        } else {// 如果是数字，就把他压入到栈中
            stk[top++] = atoi(token);
        }
    }
    // 最后栈中只有一个元素，取出即可
    return stk[top - 1];
}

Python：

def evalRPN(self, tokens):
    stack = []
    for token in tokens:
        if token in '+-*/':  # 判断是否是符号
            num1 = stack.pop()
            num2 = stack.pop()
            stack.append(str(int(eval(num2 + token + num1))))
        else:
            stack.append(token)
    return int(stack[0])