数据结构面试之四——队列的常见操作

最新推荐文章于 2025-02-25 18:16:57 发布
置顶 最新推荐文章于 2025-02-25 18:16:57 发布
阅读量582 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mark555/article/details/20766783
本文详细介绍了队列的基本操作，并通过数组、链表和栈三种不同方式实现队列，深入理解队列的工作原理及其实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据结构面试之四——队列的常见操作

题注：《面试宝典》有相关习题，但思路相对不清晰，排版有错误，作者对此参考相关书籍和自己观点进行了重写，供大家参考。

四、队列的基本操作

1.用数组构造队列

队列即是满足先进先出的链表。用数组存储的话，同样需要满足队列头front出栈，队列末尾rear入栈。而对于数组来讲，rear和front可以代表数组头和尾。不能简单的固定rear和front的大小为maxSize和0，因为可能出现中间元素为空的现象。所以，对于数组队列来讲，可以想象成环式存储，因为每一次入队后rear+1，每一次出队后front+1。这就需要控制front和rear的大小，每一次修改只要满足front=（front+1）%maxSize，rear=（rear+1）%maxSize即可满足要求。

       同样需要注意：入队操作前先判定队列是否已经满；出队操作前先判定队列是否为空。

[cpp]  view plain copy
  1. template<typename Type>  
  2. class arrQueue  
  3. {  
  4. public:  
  5.        arrQueue(intnSize=100);  
  6.        ~arrQueue();  
  7.        arrQueue(constarrQueue<Type>& copyQueue);  
  8.        arrQueue&operator=(const arrQueue<Type>& otherQueue);  
  9.    
  10.        voidinitializeQueue();  
  11.        void destroyQueue();  
  12.        bool isQueueEmpty();  
  13.        bool isQueueFull();  
  14.        void addQueue(constType& item);  
  15.        void deQueue(Type&deletedItem);  
  16.    
  17. private:  
  18.        int maxSize;  
  19.        int rear;  
  20.        int front;  
  21.        Type* list;  
  22. };  
  23.    
  24. template<typename Type>  
  25. arrQueue<Type>::arrQueue(int nSize=100)  
  26. {  
  27.        if(nSize < 0)  
  28.        {  
  29.               nSize = 100;  
  30.               list = newType[nSize];  
  31.               front = 0;  
  32.               rear = 0;  
  33.               maxSize = 100;  
  34.        }  
  35.        else  
  36.        {  
  37.               list = newType[nSize];  
  38.               front = 0;  
  39.               rear = 0;  
  40.               maxSize =nSize;  
  41.        }  
  42. }  
  43.    
  44. template<typename Type>  
  45. arrQueue<Type>::~arrQueue()  
  46. {  
  47.        if(!list)  
  48.        {  
  49.               delete[]list;                  //注意数组的删除，为delete []list;  
  50.               list = NULL;  
  51.        }  
  52. }  
  53.    
  54. template<typename Type>  
  55. arrQueue<Type>::arrQueue(const arrQueue<Type>©Queue)  
  56. {  
  57.        maxSize =copyQueue.maxSize;  
  58.        front =copyQueue.front;  
  59.        rear = copyQueue.rear;  
  60.        list = newType[maxSize];            //注意需要自定义大小,容易出错.  
  61.        for( int i = 0; i <rear; i++)  
  62.        {  
  63.               list[i] =copyQueue.list[i];  
  64.        }  
  65. }  
  66.    
  67. template<typename Type>  
  68. arrQueue<Type>& arrQueue<Type>::operator=(constarrQueue<Type>& otherQueue)  
  69. {  
  70.        if(this ==&otherQueue)  
  71.        {  
  72.               cout <<"can't copy oneSelf!" << endl;  
  73.               return *this;  
  74.        }  
  75.        else  
  76.        {  
  77.               if(maxSize !=otherQueue.maxSize)  
  78.               {  
  79.                      cout<< "The Size of two Queue are not equal!" << endl;  
  80.                      return*this;  
  81.               }  
  82.               else  
  83.               {  
  84.                      maxSize= otherQueue.maxSize;  
  85.                      front =otherQueue.front;  
  86.                      rear =otherQueue.rear;  
  87.                      for( inti = 0; i < rear; i++)  
  88.                      {  
  89.                             list[i]= otherQueue.list[i];  
  90.                      }//endfor  
  91.                      return*this;  
  92.               }  
  93.        }//end else  
  94. }  
  95.    
  96. template<typename Type>  
  97. void arrQueue<Type>::initializeQueue()  
  98. {  
  99.        destroyQueue();  
  100. }  
  101.    
  102. template<typename Type>  
  103. void arrQueue<Type>::destroyQueue()  
  104. {  
  105.        front = 0;  
  106.        rear = 0;  
  107. }  
  108.    
  109. //栈空的判定标志rear==front[初始]  
  110. template<typename Type>  
  111. bool arrQueue<Type>::isQueueEmpty()  
  112. {  
  113.        return (rear ==front);  
  114. }  
  115.    
  116. //空余1位作为判定位,可以把存储结构想象成环!  
  117. //注意栈满的判定：1.保证空间都被占用;  
  118. //2.保证rear的下一个位置=front即为满。  
  119. template<typename Type>  
  120. bool arrQueue<Type>::isQueueFull()  
  121. {  
  122.        return((rear+1)%maxSize == front);   
  123. }  
  124.    
  125. template<typename Type>  
  126. void arrQueue<Type>::addQueue(const Type& item)  
  127. {  
  128.        if(!isQueueFull())  
  129.        {  
  130.               list[rear] =item;  
  131.               rear =(rear+1)%maxSize;  
  132.               cout << item<< " was added to Queue!" << endl;  
  133.        }  
  134.        else  
  135.        {  
  136.               cout <<"The Queue was already Full!" << endl;  
  137.        }  
  138. }  
  139.    
  140. template<typename Type>  
  141. void arrQueue<Type>::deQueue(Type& deletedItem)  
  142. {  
  143.        if(!isQueueEmpty())  
  144.        {  
  145.               deletedItem =list[front];  
  146.               front =(front+1)%maxSize;                  //注意此处的判定!  
  147.               cout <<deletedItem << " was deleted from Queue!" << endl;  
  148.        }  
  149.        else  
  150.        {  
  151.               cout <<"The Queue was already Empty!" << endl;  
  152.        }  
  153. }  

2.队列采用链表链式存储结构

注意：1）此时的front和rear都变成了指针，front变成了头结点指针，而rear变成了尾节点的指针。2）此处的front和rear类似于链表操作中的first和last。3）入队实现主要在队列尾部实现，需要调整rear指针的指向；而出队操作主要在队头实现，需要调整front指针的指向。

[cpp]  view plain copy
  1. template<typename Type>  
  2. struct nodeType  
  3. {  
  4.        Type info;  
  5.        nodeType* link;  
  6. };  
  7.    
  8. template<typename Type>  
  9. class linkedQueue  
  10. {  
  11. public:  
  12.        linkedQueue();  
  13.        ~linkedQueue();  
  14.        linkedQueue(constlinkedQueue<Type>&);  
  15.        linkedQueue&operator=(const linkedQueue<Type>&);  
  16.    
  17.        voidinitializeQueue();  
  18.        void destroyQueue();  
  19.        bool isQueueEmpty()const;  
  20.        bool isQueueFull()const;  
  21.        void addQueue(constType& item);  
  22.        void deQueue(Type&poppedItem);  
  23.        void nodeCount();  
  24.    
  25. private:  
  26.        nodeType<Type>*rear;  
  27.        nodeType<Type>*front;  
  28.        int count;         //统计节点个数  
  29. };  
  30.    
  31. template<typename Type>  
  32. linkedQueue<Type>::linkedQueue()  
  33. {  
  34.        count = 0;  
  35.        front = NULL;  
  36.        rear = NULL;  
  37. }  
  38.    
  39. template<typename Type>  
  40. linkedQueue<Type>::~linkedQueue()  
  41. {  
  42.        while( front != NULL )  
  43.        {  
  44.               nodeType<Type>*tempNode = new nodeType<Type>;  
  45.               tempNode =front;  
  46.               front =front->link;  
  47.    
  48.               deletetempNode;  
  49.        }  
  50.        //注意rear的清空  
  51.        rear = NULL;  
  52. }  
  53.    
  54. template<typename Type>  
  55. linkedQueue<Type>::linkedQueue(constlinkedQueue<Type>& copyQueue)  
  56. {  
  57.        if(copyQueue.front !=NULL)  
  58.        {  
  59.               nodeType<Type>*current;  
  60.               nodeType<Type>*first;  
  61.               nodeType<Type>*newNode;  
  62.    
  63.               front = newnodeType<Type>;  
  64.               front->info= copyQueue.front->info;          //此处的top不能直接用，内存报错！  
  65.               front->link= copyQueue.front->link;  
  66.    
  67.               first =front;                        //first跟进当前链表...  
  68.               current =copyQueue.front->link;      //current跟进copy链表...  
  69.               while( current!= NULL)  
  70.               {  
  71.                      newNode= new nodeType<Type>;  
  72.                      newNode->link= current->link;  
  73.                      newNode->info= current->info;  
  74.    
  75.                      first->link= newNode;  
  76.                      first =newNode;  
  77.                      current= current->link;  
  78.               }//end while  
  79.               rear = current;  
  80.               count =copyQueue.count;  
  81.        }//end if  
  82.        else  
  83.        {  
  84.               front = NULL;  
  85.               rear = NULL;  
  86.               count = 0;  
  87.        }  
  88. }  
  89.    
  90. template<typename Type>  
  91. linkedQueue<Type>& linkedQueue<Type>::operator=(constlinkedQueue<Type>& otherQueue)  
  92. {  
  93.        //1避免自身赋值  
  94.        if(this ==&otherQueue)  
  95.        {  
  96.               cout <<"Can't copy oneself!" << endl;  
  97.               return *this;  
  98.        }  
  99.        //2其他  
  100.        else  
  101.        {  
  102.               if(front !=NULL)  
  103.               {  
  104.                      destroyQueue();  
  105.               }  
  106.               if(otherQueue.front!= NULL)  
  107.               {  
  108.                      nodeType<Type>*current;  
  109.                      nodeType<Type>*first;  
  110.                      nodeType<Type>*newNode;  
  111.    
  112.                      front =new nodeType<Type>;  
  113.                      front->info= otherQueue.front->info;  
  114.                      front->link= otherQueue.front->link;  
  115.                      first =front;                        //first跟进当前链表...  
  116.                      current= otherQueue.front->link;     //current跟进copy链表...  
  117.                      while(current != NULL)  
  118.                      {  
  119.                             newNode= new nodeType<Type>;  
  120.                             newNode->link= current->link;  
  121.                             newNode->info= current->info;  
  122.    
  123.                             first->link= newNode;  
  124.                             first= newNode;  
  125.                             current= current->link;  
  126.                      }//endwhile  
  127.                      rear =current;  
  128.                      count =otherQueue.count;  
  129.               }//end if  
  130.               else  
  131.               {  
  132.                      front =NULL;  
  133.                      rear =NULL;  
  134.                      count =0;  
  135.               }  
  136.               return *this;  
  137.        }  
  138. }  
  139.    
  140. template<typename Type>  
  141. void linkedQueue<Type>::initializeQueue()  
  142. {  
  143.        destroyQueue();  
  144. }  
  145.    
  146. template<typename Type>  
  147. void linkedQueue<Type>::destroyQueue()  
  148. {  
  149.        count = 0;  
  150.        //注意此处的销毁工作：需要循环判定!  
  151.        while(front != NULL)  
  152.        {  
  153.               nodeType<Type>*temp = new nodeType<Type>;  
  154.               temp = front;  
  155.               front =front->link;  
  156.        }  
  157.    
  158.        rear = NULL;  
  159. }  
  160.    
  161. template<typename Type>  
  162. bool linkedQueue<Type>::isQueueEmpty() const  
  163. {  
  164.        return (front ==NULL);  
  165. }  
  166.    
  167. template<typename Type>  
  168. bool linkedQueue<Type>::isQueueFull() const //空间非固定，动态申请!  
  169. {  
  170.        return false;  
  171. }  
  172.    
  173. template<typename Type>  
  174. void linkedQueue<Type>::addQueue(const Type& item)  
  175. {  
  176.        if(!isQueueFull())  
  177.        {  
  178.               nodeType<Type>*newNode = new nodeType<Type>;  
  179.               newNode->info= item;  
  180.               newNode->link= NULL;  
  181.    
  182.               if(front ==NULL)  
  183.               {  
  184.                      front =newNode;  
  185.                      rear =newNode;  
  186.               }  
  187.               else  
  188.               {  
  189.                      rear->link= newNode;  
  190.                      rear =newNode;  
  191.               }  
  192.               count++;  
  193.               cout <<item << " was pushed!" << endl;  
  194.        }  
  195. }  
  196.    
  197. template<typename Type>  
  198. void linkedQueue<Type>::deQueue(Type& deletedItem)  
  199. {  
  200.        if(!isQueueEmpty())  
  201.        {  
  202.               nodeType<Type>*temp = new nodeType<Type>;  
  203.               temp = front;  
  204.               deletedItem =front->info;  
  205.               front =front->link;  
  206.    
  207.               count--;  
  208.               cout <<deletedItem << " was popped!" << endl;  
  209.               delete temp;  
  210.        }  
  211. }  
  212.    
  213. template<typename Type>  
  214. void linkedQueue<Type>::nodeCount()  
  215. {  
  216.        cout <<"nodeCount = " << count << endl;  
  217. }  
  218.    

3.用栈实现队列

注意栈是先进后出，而用两个栈：栈1先进后出，栈2在栈1的基础上先进后出，就能实现了先进先出。

注意：入队addtoQueue要保证将元素放入到栈1中；而对于出队deQueue要保证将栈1的全部元素出栈pop，然后再全部入栈2，最后执行出栈2操作即可。

[cpp]  view plain copy
  1. #include"linkedStack.h"  
  2. template<typename Type>  
  3. class stackedQueue  
  4. {  
  5. public:  
  6.        stackedQueue();  
  7.        ~stackedQueue();  
  8.    
  9.        void addQueue(Type item);  
  10.        void deQueue(Type deletedItem);  
  11.         
  12.        bool isQueueEmpty();  
  13.        bool isQueueFull();  
  14.    
  15. private:  
  16.        nodeType<Type>* front;  
  17.        nodeType<Type>* rear;  
  18.        linkedStack<Type>* firstStack;  
  19.        linkedStack<Type>* secondStack;  
  20.        int nodeCnt;    //记录节点个数  
  21. };  
  22.    
  23. template<typename Type>  
  24. stackedQueue<Type>::stackedQueue()  
  25. {  
  26.        front = NULL;  
  27.        rear = NULL;  
  28.     nodeCnt = 0;  
  29.         
  30.        firstStack = new linkedStack<Type>;  
  31.        secondStack = new linkedStack<Type>;  
  32. }  
  33.    
  34. template<typename Type>  
  35. stackedQueue<Type>::~stackedQueue()  
  36. {  
  37.        while(front != NULL)  
  38.        {  
  39.               nodeType<Type>* temp;  
  40.               temp = front;  
  41.               front = front->link;  
  42.        }  
  43.        rear = NULL;  
  44.        if(firstStack != NULL)  
  45.        {  
  46.               delete firstStack;  
  47.               firstStack = NULL;  
  48.        }  
  49.        if(secondStack != NULL)  
  50.        {  
  51.               delete secondStack;  
  52.               secondStack = NULL;  
  53.        }  
  54. }  
  55.    
  56. template<typename Type>  
  57. voidstackedQueue<Type>::addQueue(Type item)  
  58. {  
  59.        if(!isQueueFull())  
  60.        {  
  61.               nodeCnt++;  
  62.               firstStack->push(item);        //单个入栈1  
  63.               cout << item << " was added toQueue!" << endl;  
  64.        }  
  65. }  
  66.    
  67. template<typename Type>  
  68. voidstackedQueue<Type>::deQueue(Type deletedItem)  
  69. {  
  70.        if(!isQueueEmpty())  
  71.        {  
  72.               while(!firstStack->isStackEmpty())  
  73.               {  
  74.                      firstStack->pop(deletedItem);              //全部出栈1  
  75.                      if(!firstStack->isStackFull())  
  76.                      {  
  77.                             secondStack->push(deletedItem);       //全部入栈2  
  78.                      }  
  79.               }  
  80.               if(!secondStack->isStackEmpty())  
  81.               {  
  82.                      secondStack->pop(deletedItem);            //单个出栈2  
  83.               }  
  84.               cout << deletedItem << " was out ofQueue!" << endl;  
  85.               nodeCnt--;  
  86.        }  
  87. }  
  88.    
  89. template<typename Type>  
  90. boolstackedQueue<Type>::isQueueEmpty()  
  91. {  
  92.        return (nodeCnt == 0);  
  93. }  
  94.    
  95. template<typename Type>  
  96. boolstackedQueue<Type>::isQueueFull()  
  97. {  
  98.        return false;  
  99. }  
算法与数据结构面试宝典——常见的数据结构都有哪些？详细示例（C#，C++）
qq_35320456的博客
06-30 816
本文详细讲解了C#和C++中常见的数据结构及其应用场景，并提供了示例代码。掌握这些数据结构对于算法与数据结构面试至关重要。希望读者通过本文能够更好地理解和应用这些数据结构。
【JS数据结构】线性结构——队列
早睡早起长头发的博客
10-15 1061
一. 队列结构 1.队列(Queue) 2.生活中类似的队列结构 3.队列的图解 4.队列在程序中的应用 二. 队列实现 1.队列的创建 1.1 创建自己的类, 来表示一个队列 1.2 代码解析 2.队列的操作 2.1 方式一 2.2 方式二——建议使用 三. 优先级队列 1.优先级队列的特点 2.优先级队列应用 3.优先级队列的实现 四. 队列面试题 1.击鼓传花
队列的各种基本操作
12-21
队列的各种基本操作，如插入，删除，遍历等
队列的常见操作
晴空
01-29 200
示例代码，感觉这一部分应该结合数据结构的代码来多看看，可惜一时半会回不去。。 队列先进先出 //清空clear() void clear(){ front = rear = -1; } //获取队列内元素的个数size() int size(){ return rear - front; } //判空empty() bool empty(){ if(front == rear) retu...
数据结构——队列的基本操作
far away
05-17 848
循环队列： #include #define N 5 //为了测试是否能循环，开的比较小 using namespace std; typedef int QElemTyp; bool f; struct SqQueue { QElemTyp *base; int front; int rear; }; void init(SqQueue &q) { q.b
队列的基本操作
不知道起啥名称的博客
04-05 454
首先 我认为队列就是对链表进行尾插入头删除实现代码如下：#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct node3 { int nValue; struct node3 *pNext; }MyQueue; typedef struct node4 { int nCount; MyQueue *pHead; ...
数据结构——队列 （队列结构、队列实现、优先级队列、队列面试题）
qq_52301431的博客
08-22 521
普通的队列插入一个元素, 数据会被放在后端. 并且需要前面所有的元素都处理完成后才会处理前面的数据.- 比如每个线程处理的任务重要性不同, 我们可以通过优先级的大小, 来决定该线程在队列中被处理的次序.- 比较完成后, 可以得出这个元素正确的队列中的位置. 其他处理方式, 和队列的处理方式一样.一旦优先级, 大于某个元素, 就将该元素插入到元素这个元素的位置. 其他元素会依次向后移动.- `dequeue()`：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。
数据结构经典面试之列表——C#和C++篇
qq_35320456的博客
06-22 1243
在编程中，列表是一种非常常见的数据结构，它用于存储一系列元素，这些元素可以是数字、字符、字符串等。本文将详细介绍C#和C++中的列表数据结构，并通过示例来说明如何使用它们。
数据结构经典面试之数组——C#和C++篇
qq_35320456的博客
06-20 1133
数组是一种基础且重要的数据结构，在C#和C++这两种编程语言中都有广泛的应用。通过本文的介绍，希望你对数组的概念、特点以及在C#和C++中的使用方法有了更深入的了解。在实际编程过程中，熟练掌握数组的使用对于提高代码效率和性能具有重要意义。在编程中，我们应该根据具体需求选择合适的数据结构。数组适合于处理固定数量和类型的元素，但如果元素数量或类型需要动态变化，可能需要考虑使用其他数据结构，如列表、字典等。此外，随着编程技能的提高，了解和掌握更高级的数据结构将有助于我们编写更高效、更灵活的代码。
数据结构——栈和队列详解
最新发布
ccf3699f的博客
02-25 1320
后进先出就像吃甜筒一样，先放进去的在底下，后放进去的在上面，先吃上面的，再吃下面的；当然，我们也可以放一点吃一点，这样也可以达到先进先出的效果，在数据结构中也是如此。栈是一种特殊的线性表，遵循着后进先出的原则（Last In First Out ）,只允许在数据的一端进行数据的插入与删除，这一端称为栈顶。栈顶（top） ：线性表允许进行插入与删除的一端，即栈中最后一个被插入元素的位置。队头（Front）：队列第一个元素所在位置，允许删除的一端。队尾（Rear）：队列最后一个元素所在位置，允许插入的一段。
C++学习之操作符重载
u013511885的博客
11-25 377
二十 操作符重载(operator) 1 基本概念 操作符重载就是一些具有特殊名称的函数，“operator操作符”，把已存在操作进行重新定义，针对自定义的类类型对象，完成自定义的运算功能. eg:复数 (1+2i) + (3+4i) = 4+6i 2 双目操作符重载: L#R 1.1 运算类的双目操作符：+ - … –》表达式结果是右值，不能对表达式结果再赋值 –》左右操作数既可以是左值也可以是...
数据结构之队列的基本实现
小马同学
02-26 1630
队列的基本功能实现
栈的表示和实现
悠悠的专栏
12-17 3111
一、            栈的概念 栈（stack）是插入和删除操作限定在表尾进行的线性表。 栈的逻辑表示：S=（a1，a2，…，an）        表尾元素an称为栈顶（top）        表头元素a1称为栈底（bottom） 不含元素的表称为空栈 栈的运算特征是后进先出（Last In First Out—LIFO）或者先进后出（FirstIn Last Out—FILO）
编写队列 初始化时发现 rear， front指向末尾的好处 <Java>
wo_sxn的博客
08-29 1324
队列源程序： public class MyQueue { private static int capacity = 100; private static int front, tear; private static Student[] list; public MyQueue(int cap) { capacity = cap; list = new Student[
增加了front和rear后的顺序队列
lzjsqn的专栏
05-10 2641
头文件 #ifndef __SEQQUEUE_H__ #define __SEQQUEUE_H__ typedef void SeqQueue; SeqQueue* SeqQueue_Create(int capacity); void SeqQueue_Destroy(SeqQueue* queue); void SeqQueue_Clear(SeqQueue* queue); in
队列 front rear
weixin_34195364的博客
12-14 2726
（队列）只允许在一端进行插入操作，而在另一端进行删除操作的线性表 与栈相反，队列是一种先进先出的线性表（First In First Out, FIFO） 与栈相同的是 一种重要的线性 结构，实现一个队列同样需要顺序表或链表作为基础 ######链队列 typedef struct QNode{ ElemType data; struct QNode \*next; } ...
堆、栈和队列的区别
希哈科技
11-04 2705
目录 数据结构中的堆、栈和队列 内存申请中的堆和栈 一个C/C++程序占用的内存如下： 申请内存后的响应 申请大小的限制 申请效率的比较 堆和栈中的存储内容 数据结构中的堆、栈和队列 堆：堆是一种经过排序的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。由于堆的这个特性，常用来实现优先队列，堆的存取是随意，这就如同我们在图书馆的书架上取书，虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一..
C#实现：面试算法必备——文件夹操作与数据结构
- 优先队列（堆）：作为数据结构，可以在寻找最小k个数时提供高效性能，替代数组进行操作。 2. **算法设计方法**： - **贪心算法**：如最小生成树（Prim、Kruskal算法）和最短路径（Dijkstra算法），这些不改变...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值