全球十大独角兽（完整榜单），你猜中国占几席？

最新推荐文章于 2024-11-06 09:59:41 发布

宫水三叶的刷题日记

最新推荐文章于 2024-11-06 09:59:41 发布

阅读量742

点赞数 10

文章标签：后端

本文链接：https://blog.csdn.net/weixin_33243821/article/details/142714210

版权

全球十大独角兽

10月3日，OpenAI 宣布已完成 66 亿美元融资，估值达 1570 亿美元，成为全球第三的独角兽。

给新来的读者重温一下"独角兽"的定义：估值超过10亿美元的未上市企业。

你可能会好奇，OpenAI 是第三，那前两位是谁？

「字节跳动」和「SpaceX」。

前者估值 2250 亿美元，后者估值 2000 亿美元。

字节跳动的成功，先是依靠「精准个性化内容，在移动互联网场景中落地」作为开端，再利用「产品创新、快速迭代和全球化视野」来实现可持续的高速增长。

SpaceX 在创始人埃隆·马斯克信奉的"第一性原理"下，将火箭发射价格降低了近 10 倍。SpaceX 前期依靠于和 NASA 的多份商业卫星发射服务合同得以存活，后期依靠于和 NASA 的商业轨道运输服务合同、商业载人航天以及星链（Starlink）实现盈利。

前三都聊到了，干脆一览全球十大独角兽都是哪些：

ByteDance：中国，以推荐算法驱动的内容平台今日头条和短视频平台抖音（国际版为 TikTok）而闻名
SpaceX：美国，由埃隆·马斯克（Elon Musk）创立的太空探索技术公司
OpenAI：美国，人工智能领域的领跑全球的公司
Stripe：美国，提供在线支付处理解决方案的公司
SHEIN：发源于中国，但一直强调自己是新加坡的公司，专注于快时尚（服饰和配件）的跨国电子商务公司
Revolut：英国，提供金融科技服务（包括数字银行账户、信用卡和投资服务）的公司
Databricks：美国，专注于大数据处理和分析的平台
Fanatics：美国，专注于体育商品的在线零售的电子商务公司
Canva：澳大利亚，一个在线图形设计平台
Chime：美国，一家提供移动银行服务的金融科技公司

没想到吧？全球十大独角兽公司里，有 1.5 家是中国企业。

但实际上，可能是 2.5 家。

大家都忽略了，那家上市被中止的企业：蚂蚁金服。

在被喊停前，当时普遍认为蚂蚁上市后市值可以冲击 2 万亿人民币，要知道当时整个科创板加起来才 2.4 万亿。

这全球前十独角兽榜单，大家有何看法？

有多少家是你认识的？又有哪些企业是你觉得应该上榜的？

欢迎评论区交流。

...

回归主题。

来一道和「字节跳动」相关的算法题。

题目描述

平台：LeetCode

题号：897

给你一棵二叉搜索树，请你按中序遍历将其重新排列为一棵递增顺序搜索树，使树中最左边的节点成为树的根节点，并且每个节点没有左子节点，只有一个右子节点。

示例 1：

输入：root = [5,3,6,2,4,null,8,1,null,null,null,7,9]

输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

示例 2：

输入：root = [5,1,7]

输出：[1,null,5,null,7]

提示：

树中节点数的取值范围是

基本思路

由于给定的树是一棵「二叉搜索树」，因此只要对其进行「中序遍历」即可得到有序列表，再根据有序列表构建答案即可。

而二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。

递归

递归写法十分简单，属于树的遍历中最简单的实现方式。

Java 代码：

class Solution {
    List<TreeNode> list = new ArrayList<>();
    public TreeNode increasingBST(TreeNode root) {
        dfs(root);
        TreeNode dummy = new TreeNode(-1);
        TreeNode cur = dummy;
        for (TreeNode node : list) {
            cur.right = node;
            node.left = null;
            cur = node;
        }
        return dummy.right;
    }
    void dfs(TreeNode root) {
        if (root == null) return ;
        dfs(root.left);
        list.add(root);
        dfs(root.right);
    }
}

C++ 代码：

class Solution {
public:
    vector<TreeNode*> list;
    TreeNode* increasingBST(TreeNode* root) {
        dfs(root);
        TreeNode* dummy = new TreeNode(-1);
        TreeNode* cur = dummy;
        for (auto node : list) {
            cur->right = node;
            node->left = nullptr;
            cur = node;
        }
        return dummy->right;
    }
    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->left);
        list.push_back(root);
        dfs(root->right);
    }
};

Python 代码：

class Solution:
    def increasingBST(self, root: TreeNode) -> TreeNode:        
        self.list = []
        self.dfs(root)
        dummy = TreeNode(-1)
        cur = dummy
        for node in self.list:
            cur.right = node
            node.left = None
            cur = node
        return dummy.right
    
    def dfs(self, root):
        if root:
            self.dfs(root.left)
            self.list.append(root)
            self.dfs(root.right)

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

迭代

迭代其实就是使用「栈」来模拟递归过程，也属于树的遍历中的常见实现形式。

一般简单的面试中如果问到树的遍历，面试官都不会对「递归」解法感到满意，因此掌握「迭代/非递归」写法同样重要。

Java 代码：

class Solution {
    public TreeNode increasingBST(TreeNode root) {
        List<TreeNode> list = new ArrayList<>();
        Deque<TreeNode> d = new ArrayDeque<>();
        while (root != null || !d.isEmpty()) {
            while (root != null) {
                d.add(root);
                root = root.left;
            }
            root = d.pollLast();
            list.add(root);
            root = root.right;
        }   
        TreeNode dummy = new TreeNode(-1);
        TreeNode cur = dummy;
        for (TreeNode node : list) {
            cur.right = node;
            node.left = null;
            cur = node;
        }
        return dummy.right;
    }
}

C++ 代码：

class Solution {
public:
    TreeNode* increasingBST(TreeNode* root) {
        vector<TreeNode*> list;
        deque<TreeNode*> d;
        while (root != nullptr || !d.empty()) {
            while (root != nullptr) {
                d.push_back(root);
                root = root->left;
            }
            root = d.back();
            d.pop_back();
            list.push_back(root);
            root = root->right;
        }
        TreeNode* dummy = new TreeNode(-1);
        TreeNode* cur = dummy;
        for (auto node : list) {
            cur->right = node;
            node->left = nullptr;
            cur = node;
        }
        return dummy->right;
    }
};

Python 代码：

class Solution:
    def increasingBST(self, root: TreeNode) -> TreeNode:
        lst = []
        d = []
        while root or d:
            while root:
                d.append(root)
                root = root.left
            root = d.pop()
            lst.append(root)
            root = root.right
        dummy = TreeNode(-1)
        cur = dummy
        for node in lst:
            cur.right = node
            node.left = None
            cur = node
        return dummy.right