STL算法_heap算法篇

最新推荐文章于 2021-05-30 09:50:49 发布
最新推荐文章于 2021-05-30 09:50:49 发布
阅读量1.5k 收藏
点赞数
分类专栏： STL源码剖析学习 STL源码阅读总结 文章标签： heap stl 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzhang6_10/article/details/51292127
版权

STL算法_heap算法篇

  • 堆简介

    二叉堆是一种完全二叉树，即整棵二叉树中除了最底层的叶子节点之外，其余节点是填满的，而最底层的叶子节点由左到右也是填满的不能存在空隙。

    堆主要包括两类：大顶堆和小顶堆。大顶堆指每个节点的键值（key）都大于或等于其叶子节点的键值，而小顶堆指每个节点键值都小于等于其节点的键值。STL中堆主要使用vector/array实现的。大顶堆的最大值在根节点，故其总是位于底层的vector/array的起头处；小顶堆的最小值在根节点，故其总是位于vector/array的起头处。

    此算法只要存在于stl_heap.h中，主要有make_heap()，push_heap()，pop_heap()，sort_heap()。

  • make_heap()算法

    此算法用于将一段现有的数据转化为一个heap，即构建二叉堆的过程。

    // 以下这组make_heap()不允许指定“大小比较标准”
template <class _RandomAccessIterator, class _Tp, class _Distance>
void 
__make_heap(_RandomAccessIterator __first,
            _RandomAccessIterator __last, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;      // 如果长度为0或1，不必重新排列
  _Distance __len = __last - __first;
  // 找出第一个需要重排的子树头部，以parent标示出。由于任何叶节点都不需执行percolate down，所以
  // 有以下计算。parent命名不佳，名为holeIndex更好
  _Distance __parent = (__len - 2)/2;

  while (true) {
    // 重排以parent为首的子树。len是为了让__adjust_heap()判断操作范围
    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
    if (__parent == 0) return;           // 走完根节点，就结束
    __parent--;                          // (已重排之子树的)头部向前一个节点
  }
}
// 利用所给的数组建立堆，其主要涉及调整底部vector中元素使其满足堆的条件
// 将[first, last)排列为一个heap
// 版本1
template <class _RandomAccessIterator>
inline void 
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
                 _LessThanComparable);
  __make_heap(__first, __last,
              __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
}

template <class _RandomAccessIterator, class _Compare,
          class _Tp, class _Distance>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
            _Compare __comp, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;
  _Distance __len = __last - __first;    // 计算堆的长度
  _Distance __parent = (__len - 2)/2;    // 计算根节点位置

  while (true) {
      // 调整排列元素，使其满足堆
    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
                  __comp);
    if (__parent == 0) return;
    __parent--;
  }
}
// 将[first, last)排列为一个heap
// 版本2
template <class _RandomAccessIterator, class _Compare>
inline void 
make_heap(_RandomAccessIterator __first, 
          _RandomAccessIterator __last, _Compare __comp)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __make_heap(__first, __last, __comp,
              __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
}
// 对排序算法
template <class _RandomAccessIterator>
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
                 _LessThanComparable);
  // 以下，每执行一次pop_heap()，极值（在STL heap中为极大值）即被放在尾端。扣除尾端再执行一次pop_heap()，次极值
  // 又被放在新尾端。一直下去，最后即得到排序结果
  while (__last - __first > 1)
    pop_heap(__first, __last--);     // 每执行pop_heap()一次，操作范围即退缩一格
}

  • push_heap()算法

    在堆中添加一个元素。为了满足完全二叉树的条件，新加入的元素一定要放在最下一层作为叶子节点，并填补在从左到右的第一个空格出，即将新元素插入在底层vector/array的end()处。插入后，为了满足堆（以大顶堆为例）的条件，还需要执行上溯操作：即将新节点与其父节点比较，如果其键值大于父节点，就将父子对换位置。如此一直上溯，直到不需对换或直到根节点为止。

    // 以下这组push_back()不允许指定“大小比较标准”
template <class _RandomAccessIterator, class _Distance, class _Tp>
void 
__push_heap(_RandomAccessIterator __first,
            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
    // 当尚未达到顶端，且父节点小于新值（于是不符合heap的次序特性）
    // 由于以上使用operator<，可知STL heap是一种max-heap（大者为父）
    *(__first + __holeIndex) = *(__first + __parent);    // 令洞者为父节点
    __holeIndex = __parent;                              // percolate up：调整洞号，向上提升至父节点
    __parent = (__holeIndex - 1) / 2;                    // 新洞的父节点
  }    
  *(__first + __holeIndex) = __value;                    // 令洞值为新值，完成插入操作
} 

template <class _RandomAccessIterator, class _Distance, class _Tp>
inline void 
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Distance*, _Tp*)
{
  // 根据implicit represention heap的结构特性：新值必置于底部容器的最尾端，此即第一个洞号：(last-first)-1
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
              _Tp(*(__last - 1)));
}
// push_heap函数，在堆中插入一个新元素
// 版本1
template <class _RandomAccessIterator>
inline void 
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
                 _LessThanComparable);
  // 注意：此函数被调用时，新元素应已置于底部容器的最尾端
  __push_heap_aux(__first, __last,
                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
}
template <class _RandomAccessIterator, class _Distance, class _Tp, 
          class _Compare>
void
__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
            _Distance __topIndex, _Tp __value, _Compare __comp)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
    *(__first + __holeIndex) = *(__first + __parent);
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }
  *(__first + __holeIndex) = __value;
}
template <class _RandomAccessIterator, class _Compare,
          class _Distance, class _Tp>
inline void 
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Compare __comp,
                _Distance*, _Tp*) 
{
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
              _Tp(*(__last - 1)), __comp);
}
// 版本2
template <class _RandomAccessIterator, class _Compare>
inline void 
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
          _Compare __comp)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __push_heap_aux(__first, __last, __comp,
                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
}

  • pop_heap()算法

    在堆中删除根元素。下面以大顶堆为例，取走根节点（实质是设置底部容器vector/array的尾端节点）后，为了满足完全二叉树的条件，必须割舍最下层最右边的叶节点，并将其值重新安插到大顶堆的顶点（即vector/array的首端）。取走根元素后，为了满足大顶堆的条件，还需要执行下溯操作：即将此时的根节点值与其较大的自己子节点比较，如果其子节点更大，则交换，然后持续下方，直到不需对换或达到叶节点为止。

    // __adjust_heap（调整堆）算法：主要用于调整排列中的数据，使其满足堆的性质。此算法主要用在pop_heap()算法中。
// 以下这个__adjust_heap()不允许指定“大小比较标准”
// 版本1
template <class _RandomAccessIterator, class _Distance, class _Tp>
void 
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;       // 洞节点之右子节点
  while (__secondChild < __len) {
    // 比较洞节点之左右两个子值，然后以secondChild代表较大的子节点
    if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
      __secondChild--;
    // percolate down：令较大值为洞值，再令洞号下移至较大子节点处
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    // 找出新洞节点的右子节点
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {                        // 没有右子节点，只有左子节点
    // percolate down：令左子值为洞值，再令洞号下移至左子节点处
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  // 此时可能尚未满足次序特性。执行一次percolate up操作
  __push_heap(__first, __holeIndex, __topIndex, __value);
}
template <class _RandomAccessIterator, class _Tp, class _Distance>
inline void 
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Distance*)
{
  *__result = *__first;    // 设定尾指为首值，于是尾值即为欲求结果，可由客户端稍后再以底层容器之pop_back()取出尾值
  // 以上欲重新调整heap，洞号为0（亦即树根处），欲调整值为value（原尾值）
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
}
template <class _RandomAccessIterator, class _Tp>
inline void 
__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last,
               _Tp*)
{
  // 根据implicit represention heap的次序特性，pop操作的结果应为底部容器的第一个元素。因此，首先
  // 设定欲调整值为尾值，然后将首值调至尾节点（所以以上将迭代器result设为last-1），然后重整[first,
  // last-1)，使之重新成一个合格的heap
  __pop_heap(__first, __last - 1, __last - 1, 
             _Tp(*(__last - 1)), __DISTANCE_TYPE(__first));
}
// pop_heap算法，从堆中删除元素
// 版本1
template <class _RandomAccessIterator>
inline void pop_heap(_RandomAccessIterator __first, 
                     _RandomAccessIterator __last)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
                 _LessThanComparable);
  __pop_heap_aux(__first, __last, __VALUE_TYPE(__first));
}
// 调整堆，版本2
template <class _RandomAccessIterator, class _Distance,
          class _Tp, class _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value, _Compare __comp)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;
  while (__secondChild < __len) {
    if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  __push_heap(__first, __holeIndex, __topIndex, __value, __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Compare, 
          class _Distance>
inline void 
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Compare __comp,
           _Distance*)
{
  *__result = *__first;
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), 
                __value, __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Compare>
inline void 
__pop_heap_aux(_RandomAccessIterator __first,
               _RandomAccessIterator __last, _Tp*, _Compare __comp)
{
  __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp,
             __DISTANCE_TYPE(__first));
}
// 版本2
template <class _RandomAccessIterator, class _Compare>
inline void 
pop_heap(_RandomAccessIterator __first,
         _RandomAccessIterator __last, _Compare __comp)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __pop_heap_aux(__first, __last, __VALUE_TYPE(__first), __comp);
}

  • sort_heap()算法

    因为堆中每次执行pop_heap可获得堆中（大顶堆为例）中键值的最大元素，如果持续对整个heap做pop_heap操作，每次将操作范围从后向前缩减一个元素（pop_heap会把键值最大的元素放在底部容器的最尾端），当整个程序执行完毕时，便可得到递增的序列，即实现利用堆进行排序。

    // 堆排序算法，主要利用pop\_heap()算法实现
// 版本1
template <class _RandomAccessIterator>
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
                 _LessThanComparable);
  // 以下，每执行一次pop_heap()，极值（在STL heap中为极大值）即被放在尾端。扣除尾端再执行一次pop_heap()，次极值
  // 又被放在新尾端。一直下去，最后即得到排序结果
  while (__last - __first > 1)
    pop_heap(__first, __last--);     // 每执行pop_heap()一次，操作范围即退缩一格
}
// 版本2
template <class _RandomAccessIterator, class _Compare>
void 
sort_heap(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  while (__last - __first > 1)
    pop_heap(__first, __last--, __comp);
}

  • 参考文献

    STL源码剖析——侯捷

    STL源码

Dream_yz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sort_heap push_heap pop_heap 堆的各种算法
05-03
最近在学习STL的源代码，看到这么多优秀的代码，心里痒痒的，于是自己实现了一遍，当然，有自己的特色，都是模块函数，稍稍用了一些traits特性。相互学习，呵呵
c语言实现大顶堆思路及代码
Mrlie的博客
01-12 825
插入和删除还没写，不过删除逻辑和创建差不多，太晚了，明天写 #include<stdio.h> #include<stdlib.h> typedef struct heap { int* data; int size; int capacity; }heap; //函数：1.创建堆：返回指针、2.插入：返回指针、3.删除：返回数据、4.遍历：直接输出不返回、5.调整：返回指针、6.最大值：返回数字 heap* establish(heap*p); heap* adjus
堆排序（HeapSort）详解
Arthur_____的博客
04-17 876
1、什么是堆？ 堆是一个数据结构：其每个节点的值，大于等于其左右孩子节点的值，且为一颗完全二叉树。 堆（一棵树）可以用数组来表示。 2、大顶堆，小顶堆？ 堆又称为：大顶堆； 小顶堆：每个节点的值，小于等于其左右孩子节点的值，的完全二叉树。 用法区别： 降序排序------使用小顶堆；[6,5,4,3,2,1,0] 升序排序------使用大顶堆；[0,1,2,3,4,5,6] 3、堆用...
STL容器组件的一位幕后英雄 Heap
专注游戏研发
08-02 174
做 Heap 的忠爱粉二进制堆建堆堆排序Heap 在 STL 中的职责STL Heap 算法测试实例： 二进制堆 二叉堆是一种形态特征是完全二叉树，且数值特征是父节点优于/劣于其左右子节点的一种数据结构。 父节点优于其左右子节点的堆是大根堆 父节点劣于其左右子节点的堆是小根堆 由于形状近似完全二叉树，我们可以使用顺序结构（arr ）来表示其。 这里我们使用顺序结构表示时需要记住两个性质： 完全二叉树的父节点为对应数组下标为 N，那么它的左孩子下标为 2 * N + 1，右孩子下标是 2 * N + .
SGI STL：heap排序的adjust函数
weixin_45738036的博客
05-13 1287
SGI STL：heap排序中adjust函数 本文不介绍具体的heap排序算法，阅读之前请先熟悉STL heap排序的逻辑。本文讨论的是SGI-STL源码中__adjust_heap函数中的一个细节。先展示源码。 // 实际执行的push函数： template <class _RandomAccessIterator, class _Distance, class _Tp> void __push_heap(_RandomAccessIterator __first,
STL heap部分源码分析
poi7777的专栏
08-19 660
本文假设你已对堆排序的算法有基本的了解。 要分析stl中heap的源码的独到之处，最好的办法就是拿普通的代码进行比较。话不多说，先看一段普通的堆排序的代码：
（十一）树--堆排序
Apikaqiu的博客
05-30 282
堆排序基本介绍 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为 O(nlogn)，它也是不稳定排序。 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。(大顶堆的特点：arr[i]>=arr[2*i+1] && arr[i]>=arr[2*i+2]） 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 （小顶堆的特点：a
堆排序
willlu10的博客
03-25 140
第一步：用给定的数组构造一个大（小）顶堆，在for循环中调用构造顶堆的函数adjustHeap，初始的i=为第一个非叶子节点的下标，然后从底向上调整顶堆。arr代表待排序数组。 for(int i=arr.length/2-1;i&gt;=0;i--){ //从第一个非叶子结点从下至上，从右至左调整结构 adjustHeap(arr,i...
STL源码剖析——heap
Smile&搁浅
06-15 2459
Heap堆是常用的数据结构，Heap中也可以存放元素。但是STL中并没有提供Heap容器，只是提供了关于Heap操作的算法。只要支持RandomAccessIterator的容器都可以作为Heap容器。 Heap分为max heap和min heap，max heap中每次取出的结点时heap结构中值最大的结点，min heap中每次取出的结点时heap结构中值最小的结点。 在实际应用中，经常
堆及其算法
sicofield的专栏
03-30 1855
堆一般是一种隐式表述（implicit representation），简单的说堆是由另外一种容器实现的。由于堆中的操作都基于搜寻父节点，子节点。如果用数组的话，那么不需要额外的存储空间就可以轻松实现。左子节点标号=父节点标号*2+1；右子节点标号=父节点标号*2+2；父节点标号=（子节点标号-1）/2。如果在用一种小技巧，将标号0处元素保留（或设为无限大（小）值），从而忽略根节点的话，计算式将改
STL.zip_Map 排序_STL_Table_stl map实现
09-24
源码之前了无秘密，你将看到vector的实现、list的实现、heap的实现、deque的实现、Red Black tree的实现、hash table的实现、set/map的实现;你将看到各种算法(排序、查找、排列组合、数据移动与复制技术)的实现;你...
STL源码剖析
01-19
源码之前了无秘密，你将看到vector的实现、list的实现、heap的实现、deque的实现、RB-tree的实现、hash-table的实现、set/map 的实现；你将看到各种算法（排序、搜寻、排列组合、数据移动与复制…）的实现；你甚至将...
基于二叉堆优化的A星算法
04-08
本源代码借助标准C++ STL中的vector,list和heap等已封装的数据结构，优化了A星算法搜索地图、检索开始列表过程，减小了程序的时间和空间花费。经检验，检索20000*20000的随机障碍物地图时，程序在规划路径部分的平均...
STL算法_sort算法篇
没有最好，只有更好！
05-01 4977
STL算法_sort算法篇 简介sort算法接受两个RandomAccessIterators（随机存取迭代器），然后将区间内的所有元素以渐增方式由小到大重新排序。STL中的关系型容器都拥有自动排序功能（底层使用RB-tree实现），不需要用到sort算法。至于序列式容器中的stack、queue和priority-queue都有特别的出入口，不允许用户对元素排序。剩下vector、deque和li
STL学习_配接器篇
没有最好，只有更好！
05-02 4732
STL学习_配接器篇 定义配接器（Adapter）在STL组件的灵活组合运用功能上，扮演着轴承、转换器的角色。它事实上是一种设计模式。即将一个class的接口转换为另一个class的接口，使原本因接口不兼容而不能合作的classes，可以一起运作。 分类STL所提供的各种适配器中，改变仿函数（functors）接口者，称为function adapter；改变容器（containers）接口者，称为
STL算法_基本算法篇
没有最好，只有更好！
05-01 4483
STL算法_基本算法1）equal算法：用来比较两个序列在[first,last)区间内是否相等。如果第二个序列的元素多于第一个序列元素，则多出的元素不予考虑。// equal算法用来判断两个序列在[frist,last)区间内是否相等。当第二个序列的元素较多时，多出来的元素不予考虑。 // 版本1 template <class _InputIter1, class _InputIter2> in
STL算法_set相关算法篇
没有最好，只有更好！
05-01 4273
STL算法_set相关算法set相关算法所接受的set，必须是有序区间，元素值可以重复出现。1）set_union算法：可构造S1，S2之并集。即构造出S1并S2，此集合内含S1或S2内的每一个元素。S1、S2及其并集都是以排序区间表示。返回值是一个迭代器，指向输出区间的尾端。它是一种稳定操作，其输入区间内的每个元素的相对顺序不会改变。因S1和S2元素不唯一，如果某个值在S1中出现n次，在S2中出现
STL学习——RB-tree篇
没有最好，只有更好！
05-07 4131
STL学习——RB-tree篇 简介RB-tree（红黑树）是一棵平衡二叉搜索树，它需要满足以下规则：1）每个节点不是红色就是黑色；2）根节点为黑色；3）如果节点为红，其子节点必须为黑；4）任一节点至NULL（树尾端）的任何路径，所含之黑节点数必须相同。 插入依据红黑树的性质4）可以，在红黑树中插入节点，新插入的节点必须为红。插入节点后，可能会破坏红黑树的性质，此时需调整红黑树节点颜色或者旋转红黑树
C++语法——make_heap、push_heap、pop_heap、sort_heap使用介绍
最新发布
06-13
make_heap、push_heap、pop_heap和sort_heap都是C++ STL库中的算法，用于操作堆（heap）数据结构。 1. make_heap：将一个无序的区间转换为堆。函数原型如下： ``` template void make_heap (RandomAccessIterator...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值