备案控制台
开发者社区 开发与运维 文章 正文

红黑树（万字图文详解）

2023-12-01 43
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 红黑树（万字图文详解）



注：本文的是在理解AVL树的基础上进行讲解的！

AVL树的实现（万字图文详解）

1. 红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

2. 红黑树的性质

1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

  1. 红黑树中的性质确保了任意路径上的黑色节点数量相等，这是红黑树能够保持平衡的关键。根据这个性质，我们可以证明红黑树的最长路径中的节点个数不会超过最短路径的节点个数的两倍。
  2. 假设红黑树的最短路径上的黑色节点数量为k。由于性质5，任意路径上的黑色节点数量相等，所以最长路径上的黑色节点数量不能少于k个。
  3. 现在我们来看最长路径上的节点个数。由于性质4，红色节点的两个子节点都是黑色的，因此最长路径上不能有连续的红色节点。而对于红黑树而言，最长路径上的红色节点数量最多为k，因为最长路径上的黑色节点数量不能少于k个。所以最长路径上的节点个数最多为2k，其中k个是黑色节点，k个是红色节点。
  4. 综上所述，红黑树的最长路径中的节点个数不会超过最短路径的节点个数的两倍，即最长路径上的节点个数最多为2k，其中k为最短路径上的黑色节点数量。
  5. 这个性质保证了红黑树的高度始终保持在较小的范围内，从而保持了树的平衡性。因为红黑树的高度与最长路径上的节点个数成正比，所以最长路径的节点个数的上限为最短路径的节点个数的两倍，确保了红黑树的平衡性和高效性。

3. 红黑树节点的定义

template<class K, class V>
struct RBTreeNode
{
  RBTreeNode<K, V>* _left;
  RBTreeNode<K, V>* _right;
  RBTreeNode<K, V>* _parent;
  pair<K, V> _kv;
  Colour _col;
  int _bf;
  RBTreeNode(const pair<K, V>& kv)
    :_left(nullptr)//左孩子
    , _right(nullptr)//右孩子
    , _parent(nullptr)//父亲
    , _kv(kv)//存储键值对的成员变量
    , _col(RED)//默认红色
  {}
};

具体解释如下：

  • _left：指向左子节点的指针。
  • _right：指向右子节点的指针。
  • _parent：指向父节点的指针。
  • _kv：存储键值对的成员变量。这里使用了 pair<K, V> 类型来表示键值对，其中 K 是键的类型，V 是值的类型。
  • _col：表示节点的颜色。这里使用了 Colour 枚举类型来表示，可能的取值为 RED 或 BLACK，其中 RED 表示红色，BLACK 表示黑色。
  • _bf：平衡因子，用于平衡二叉树的调整。

4. 红黑树结构

为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为根节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点。

如下：

5. 红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

5.1 按照二叉搜索的树规则插入新节点

#pragma once
#include <iostream>
using namespace std;
//枚举类型变量
enum Colour
{
  RED,  //红
  BLACK //黑
};
template<class K, class V>
struct RBTreeNode
{
  RBTreeNode<K, V>* _left;
  RBTreeNode<K, V>* _right;
  RBTreeNode<K, V>* _parent;
  pair<K, V> _kv;
  Colour _col;
  int _bf;
  RBTreeNode(const pair<K, V>& kv)
    :_left(nullptr)
    , _right(nullptr)
    , _parent(nullptr)
    , _kv(kv)
    , _col(RED)//默认红色
  {}
};
template<class K, class V>
class RBTree
{
  typedef RBTreeNode<K, V> Node;
public:
  bool insert(const pair<K, V>& kv)
  {
    if (_root == nullptr)
    {
      _root = new Node(kv);
      _root->_col = BLACK;
      return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
      if (cur->_kv.first < kv.first)
      {
        parent = cur;
        cur = cur->_right;
      }
      else if (cur->_kv.first > kv.first)
      {
        parent = cur;
        cur = cur->_left;
      }
      else
      {
        return false;
      }
    }
    cur = new Node(kv);
    cur->_col = RED;//！应该能去掉
      if (parent->_kv.first < kv.first)
      {
        parent->_right = cur;
        cur->_parent = parent;
      }
      else
      {
        parent->_left = cur;
        cur->_parent = parent;
      }
      红黑树开整
      //1.cur为红，parent为红，grandfather为黑，uncle存在且为红
      //解决方法：p,u变成黑，g变成红，c=g，继续向上调整
      //2.cur为红，parent为红，grandfather为黑,uncle不存在 or 存在且为黑
      //解决方法: 单旋：p变红，g变黑，//双旋：c变黑，g变红
private:
  Node* _root = nullptr;
};

5.2 检测新节点插入后，红黑树的性质是否造到破坏

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

5.2.1 情况一: cur为红，p为红，g为黑，u存在且为红

解决方法：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

5.2.2 情况二: cur为红（此时只需要单旋），p为红，g为黑，u不存在/u存在且为黑

解决方法：

p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，

p为g的右孩子，cur为p的右孩子，则进行左单旋转

p、g变色–p变黑，g变红

5.2.3 情况三: cur为红（此时需要进行双旋变成情况二），p为红，g为黑，u不存在/u存在且为黑

解决方法：

  • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转，再对g右单旋即可完成调整；
  • 相反，
    p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
    ，再对g左单旋即可完成调整

完整代码

#pragma once
#include <iostream>
using namespace std;
//枚举类型变量
enum Colour
{
  RED,  //红
  BLACK //黑
};
template<class K, class V>
struct RBTreeNode
{
  RBTreeNode<K, V>* _left;
  RBTreeNode<K, V>* _right;
  RBTreeNode<K, V>* _parent;
  pair<K, V> _kv;
  Colour _col;
  int _bf;
  RBTreeNode(const pair<K, V>& kv)
    :_left(nullptr)
    , _right(nullptr)
    , _parent(nullptr)
    , _kv(kv)
    , _col(RED)//默认红色
  {}
};
template<class K, class V>
class RBTree
{
  typedef RBTreeNode<K, V> Node;
public:
  bool insert(const pair<K, V>& kv)
  {
    if (_root == nullptr)
    {
      _root = new Node(kv);
      _root->_col = BLACK;
      return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
      if (cur->_kv.first < kv.first)
      {
        parent = cur;
        cur = cur->_right;
      }
      else if (cur->_kv.first > kv.first)
      {
        parent = cur;
        cur = cur->_left;
      }
      else
      {
        return false;
      }
    }
    cur = new Node(kv);
    cur->_col = RED;//！应该能去掉
      if (parent->_kv.first < kv.first)
      {
        parent->_right = cur;
        cur->_parent = parent;
      }
      else
      {
        parent->_left = cur;
        cur->_parent = parent;
      }
      红黑树开整
      //1.cur为红，parent为红，grandfather为黑，uncle存在且为红
      //解决方法：p,u变成黑，g变成红，c=g，继续向上调整
      //2.cur为红，parent为红，grandfather为黑,uncle不存在 or 存在且为黑
      //解决方法: 单旋：p变红，g变黑，//双旋：c变黑，g变红
      //parent不为空，且parent->_col==RED（这样保证肯定有祖先，也就是grandfather不为空）
      while (parent && parent->_col == RED)
      {
        //    g
        //  p   u
        //c
        Node* grandfather = parent->_parent;
        if (parent == grandfather->_left)
        {
          //    g
            //  p   u
            //c
          Node* uncle = grandfather->_right;
          if (uncle && uncle->_col == RED)
          {
            parent->_col = uncle->_col = BLACK;
            grandfather->_col = RED;
            //继续往上更新处理
            cur = grandfather;
            parent = cur->_parent;//这儿parent更新完之后可能为空，为空就结束
          }
          else//uncle不存在 or 存在且为黑
          {   //单旋
            //    g
              //  p   u
              //c
            if (cur == parent->_left)
            {
              RotateR(grandfather);
              parent->_col = BLACK;//p变黑
              grandfather->_col = RED;//g变红
            }
            else if (cur == parent->_right)
            {
              //双旋
              //    g
              //  p   u
              //    c
              RotateL(parent);
              RotateR(grandfather);
              cur->_col = BLACK;
              grandfather->_col = RED;
            }
            break;
          }
        }
        //    g
        //  u   p
        //        c
        else//  parent == grandfather->_left
        {
          Node* uncle = grandfather->_left;
          if (uncle && uncle->_col == RED)
          {
            parent->_col = uncle->_col = BLACK;
            grandfather->_col = RED;
            //继续往上更新处理
            cur = grandfather;
            parent = cur->_parent;
          }
          else//(uncle不存在 or 存在且为黑)
          {   //单旋
            //    g         
            //  u   p           
            //        c    
            if (cur == parent->_right)
            {
              RotateL(grandfather);
              parent->_col = BLACK;//p变黑
              grandfather->_col = RED;//g变红
            } 
            else//cur == parent->_left 
            {
              //双旋
              //    g
              //  u   p
              //    c  
              RotateR(parent);
              RotateL(grandfather);
              cur->_col = BLACK;
              grandfather->_col = RED;
            }
            break;
          }
        }
      }
      //管你根节点更新成啥了，管你个求，直接把_root->_col改成黑色
      _root->_col = BLACK;
    return true;
  }
  //左单旋
  //（1.父亲节点的右边等于右孩子的左边; 2.右孩子的左边等于父亲节点）
  //【把右孩子的左边给给父亲节点的右边; 2.再把父亲节点给给右孩子的左边】
  void RotateL(Node* parent)
  {
    Node* SubR = parent->_right;
    Node* SubRL = SubR->_left;
    //旋转链接
    parent->_right = SubRL;
    SubR->_left = parent;
    Node* Parent_Parent = parent->_parent;
    parent->_parent = SubR;
    if (SubRL)
    {
      SubRL->_parent = parent;
    }
    //和父节点的父节点链接
    if (_root == parent)
    {
      _root = SubR;
      SubR->_parent = nullptr;
    }
    else
    {
      if (Parent_Parent->_left == parent)
      {
        Parent_Parent->_left = SubR;
      }
      else
      {
        Parent_Parent->_right = SubR;
      }
      SubR->_parent = Parent_Parent;
    }
  }
  //右单旋
  void RotateR(Node* parent)
  {
    Node* SubL = parent->_left;
    Node* SubLR = SubL->_right;
    //旋转链接
    //动一个节点就把他的父亲也变动
    parent->_left = SubLR;
    if (SubLR)//SubLR可能为空
    {
      SubLR->_parent = parent;
    }
    Node* Parent_Parent = parent->_parent;
    SubL->_right = parent;
    parent->_parent = SubL;
    //和父节点的父节点链接
    if (_root == parent)
    {
      _root = SubL;
      SubL->_parent = nullptr;
    }
    else
    {
      if (Parent_Parent->_left == parent)
      {
        Parent_Parent->_left = SubL;
      }
      else
      {
        Parent_Parent->_right = SubL;
      }
      SubL->_parent = Parent_Parent;//链接
    }
  }
  void InOrder()
  {
    _InOrder(_root);
    cout << endl;
  }
  void _InOrder(Node* root)
  {
    if (root == nullptr)
      return;
    _InOrder(root->_left);
    cout << root->_kv.first << " ";
    _InOrder(root->_right);
  }
  //根节点到当前这条路径的黑色节点个数
  bool Check(Node *root,int blacknum,const int RefVal)
  {
    if (root == nullptr)
    {
      if (blacknum != RefVal)
      {
        return false;
      }
      return true;
    }
    //直接反向检查，儿子很复杂，父亲只有一个
    if (root->_col == RED && root->_parent->_col == RED)
    {
      cout<<"有连续的红节点" << endl;
      return false;
    }
    if (root->_col == BLACK)
    {
      blacknum++;
    }
    return Check(root->_left, blacknum, RefVal) && Check(root->_right, blacknum, RefVal);
  }
  bool IsBalance()
  {
    if (_root == nullptr)
    {
      return true;
    }
    if (_root->_col == RED)
    {
      return false;
    }
    int blacknum = 0;//记录每条路径的黑色节点个数
    int RefVal = 0;//定一个标准
    Node* cur = _root;
    while (cur)//改了一个bug ，之前这儿脑子抽抽了，写成了if
    {
      if (cur->_col == BLACK)
      {
        ++RefVal;
      }
      cur = cur->_left;
    }
    return Check(_root, blacknum,RefVal);
  }
private:
  Node* _root = nullptr;
};

6. 红黑树的验证

红黑树的检测分为两步：

1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

#include <vector>
#include "RBTree.h"
int main()
{
  int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
  RBTree<int, int> a;
  for (auto e : arr)
  {
    a.insert(make_pair(e, e));
  }
  a.InOrder();
  return 0;
}

2. 检测其是否满足红黑树的性质

我们可以通过递归地遍历红黑树的节点，并统计根节点到每个叶子节点路径上的黑色节点个数来进行检查。

//根节点到当前这条路径的黑色节点个数
bool Check(Node *root,int blacknum,const int RefVal)
{
  if (root == nullptr)
  {
    if (blacknum != RefVal)
    {
      return false;
    }
    return true;
  }
  //直接反向检查，儿子很复杂，父亲只有一个
  if (root->_col == RED && root->_parent->_col == RED)
  {
    cout<<"有连续的红节点" << endl;
    return false;
  }
  if (root->_col == BLACK)
  {
    blacknum++;
  }
  return Check(root->_left, blacknum, RefVal) && Check(root->_right, blacknum, RefVal);
}
bool IsBalance()
{
  if (_root == nullptr)
  {
    return true;
  }
  if (_root->_col == RED)
  {
    return false;
  }
  int blacknum = 0;//记录每条路径的黑色节点个数
  int RefVal = 0;//定一个标准
  Node* cur = _root;
  while (cur)//改了一个bug ，之前这儿脑子抽抽了，写成了if
  {
    if (cur->_col == BLACK)
    {
      ++RefVal;
    }
    cur = cur->_left;
  }
  return Check(_root, blacknum,RefVal);
}

函数讲解

Check 函数是一个递归函数，用于检查从当前节点到叶子节点的路径上的黑色节点个数是否与参考值 RefVal 相等。参数 root 表示当前节点指针，blacknum 表示根节点到当前节点的路径上的黑色节点个数，RefVal 是参考值。

  • 如果当前节点为空指针，即到达了叶子节点，那么检查路径上的黑色节点个数 blacknum 是否等于参考值 RefVal，如果不相等则返回 false，否则返回 true。
  • 如果当前节点的颜色为红色，并且父节点也是红色，表示存在连续的红节点，不符合红黑树的性质，返回 false。
  • 如果当前节点的颜色为黑色，将 blacknum 值加一。
  • 递归地调用 Check 函数检查左子节点和右子节点，并将当前节点的黑色节点个数 blacknum 作为参数传递。

IsBalance 函数用于检查整个红黑树是否符合红黑树的性质。

  • 如果红黑树为空树，即根节点为空，认为是一棵合法的红黑树，返回 true。
  • 如果根节点的颜色是红色，违反了红黑树的性质，返回 false。
  • 初始化 blacknum 为 0，用于记录每条路径的黑色节点个数。
  • 初始化 RefVal 为 0，作为参考值。
  • 通过遍历从根节点到最左子节点的路径，统计参考值 RefVal，即路径上的黑色节点个数。
  • 调用 Check 函数，传入根节点、路径上的黑色节点个数 blacknum 和参考值 RefVal 进行检查。
#include <vector>
#include "RBTree.h"
int main()
{
  const int N = 30;
  vector<int> v;
  v.reserve(N);
  srand(time(0));
  for (size_t i = 0; i < N; i++)
  {
    v.push_back(rand()%100 );
  }
  RBTree<int, int> t;
  for (auto e : v)
  {
    if (e == 0)
    {
      int i = 0;
    }
    t.insert(make_pair(e, e));
    cout << "Insert" << e << "->" << t.IsBalance() << endl;
  }
  t.InOrder();//中序打印
  if (t.IsBalance())
  {
    cout << "是平衡二叉树" << endl;
  }
  else
  {
    cout << "不是平衡二叉树" << endl;
  }
  return 0;
}

7. 红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(l o g 2 N log_2 Nlog2N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

8. 红黑树的应用

  1. C++ STL库 – map/set、mutil_map/mutil_set
    C++ STL中的std::map和std::set：这些容器类通常使用红黑树作为底层数据结构，提供了高效的查找、插入和删除操作。
  2. 数据库系统：红黑树常被用作数据库索引结构，例如在关系型数据库中，可以使用红黑树来实现B+树索引，提供高效的数据检索和排序功能。
  3. 线程调度器：操作系统中的线程调度器通常需要高效地管理和调度线程，红黑树可用于实现定时器和任务调度器，以快速查找和处理就绪的线程。
  4. 路由算法：在网络路由算法中，红黑树可以用于快速查找最佳路径和路由表项，提供高效的路由查找和转发功能。
  5. linux内核
    文件系统：某些文件系统使用红黑树来管理文件和目录的索引，以支持快速的文件查找和访问。
  6. 编译器和解释器：在编译器和解释器中，红黑树可以用于符号表的实现，以支持快速的符号查找和关联。
  7. 并发数据结构：在多线程和并发编程中，红黑树可以用于实现并发安全的数据结构，例如并发哈希表、并发有序集合等。

（本章完）

文章标签：
调度
C++
索引
关系型数据库
算法
originalHSL.
目录
相关文章
阿里云Forward
|
4月前
|
存储 算法 搜索推荐
八大排序算法——（万字图文详解）
八大排序算法——（万字图文详解）
阿里云Forward
422 0
Dio夹心小面包
|
4月前
|
存储 C++
『 C++ 』红黑树RBTree详解 ( 万字 )
『 C++ 』红黑树RBTree详解 ( 万字 )
Dio夹心小面包
54 0
originalHSL.
|
5月前
|
存储 容器
AVL树的实现（万字图文详解）
AVL树的实现（万字图文详解）
originalHSL.
73 1
greework
|
11月前
|
算法 Python
算法创作|单链表基本操作问题解决方法
算法创作|单链表基本操作问题解决方法
greework
101 0
水滴技术
|
11月前
|
存储 算法 Java
Java数据结构与算法分析（十）B树图文详解（含完整代码）
迄今为止，已经介绍了《 二叉查找树 》和《 AVL树 》，我们始终假设可以把整个数据结构存储在内存中。可是，如果数据多到内存装不下，这就意味着必须把数据放在磁盘上，显然这些数据结构不再适用。 问题在于磁盘的I/O速度是远远不如内存访问速度的，然而从一棵树中查找到某个元素，必须从根节点一层层往下找，这每一次查找便是一次I/O操作。为了提高性能，就必须要减少查找的次数。 如能减少树的高度、增加每个节点中的元素数，便是种有效的解决方案。实现这种想法的一种方法是使用B树。
水滴技术
81 0
愿天堂没有BUG（公众号同名）
|
存储 JSON NoSQL
整理得吐血了，二叉树、红黑树、B&B+树超齐全，快速搞定数据结构
没有必要过度关注本文中二叉树的增删改导致的结构改变，规则操作什么的了解一下就好，看不下去就跳过，本文过多的XX树操作图片纯粹是为了作为规则记录，该文章主要目的是增强下个人对各种常用XX树的设计及缘由的了解，也从中了解到常用的实现案例使用XX树实现的原因。
愿天堂没有BUG（公众号同名）
56 0
Cyan_RA9
|
存储 算法 搜索推荐
C 单链表及其相关算法 万字详解（通俗易懂）
C 数据结构与算法入门——单链表 内容分享（包含单链表常见算法的讲解)。
Cyan_RA9
43 0
C 单链表及其相关算法 万字详解（通俗易懂）
阿紫1
|
算法 数据可视化
数据结构与算法（十二）红黑树
数据结构与算法（十二）红黑树
阿紫1
70 0
Cool架构
|
存储 算法
数据结构第三周笔记——树(上)(慕课浙大版本--XiaoYu)（二）
数据结构第三周笔记——树(上)(慕课浙大版本--XiaoYu)（二）
Cool架构
125 0
Cool架构
|
存储 算法
数据结构第三周笔记——树(上)(慕课浙大版本--XiaoYu)（三）
数据结构第三周笔记——树(上)(慕课浙大版本--XiaoYu)（三）
Cool架构
77 0

热门文章

最新文章

  • 1
    企业应用架构实践（复杂性应对之道）
  • 2
    SolidWorks2021中文版【Solid Works 附补丁】完美破解版下载 安装教程
  • 3
    3+1保障：高可用系统稳定性是如何炼成的？
  • 4
    大数据上手实战！《Elasticsearch 实战进阶营》第二季限时免费报名啦
  • 5
    OLAP与OLTP介绍
  • 6
    浅显易懂的机器学习（八）—— 随机森林分类
  • 7
    Windows 2008 AD 备份
  • 8
    《Ext JS权威指南》——2.9节为本书示例准备一个模板
  • 9
    NS2原理
  • 10
    Asp.net MVC2.0系列文章-显示列表和详细页面操作
  • 1
    Java中数组详解
    41
  • 2
    智能评估时代：SurveyKing开源问卷系统YYDS
    63
  • 3
    LabVIEW编程LabVIEW开发高级数据采集技术 操作数字IO 例程与相关资料
    37
  • 4
    【大模型】描述与 LLM 相关的个人项目或感兴趣的领域
    37
  • 5
    【大模型】使用哪些资源来了解 LLM 的最新进展？
    47
  • 6
    LabVIEW编程LabVIEW开发高级数据采集技术 计数器定时器的操作 例程与相关资料
    25
  • 7
    LabVIEW编程LabVIEW开发高级数据采集技术 模拟波形的生成 例程与相关资料
    23
  • 8
    Linux：进程等待 & 进程替换
    27
  • 9
    LabVIEW编程LabVIEW开发高级数据采集技术 同步 例程与相关资料
    19
  • 10
    LabVIEW编程LabVIEW开发高级数据采集技术定时与触发 例程与相关资料
    18

    • 相关电子书

    更多
  • 超全算法笔试 模拟题精解合集
  • 超全算法笔试-模拟题精解合集
  • 图解算法小抄
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）