登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 科技 ›循环队列的接口

循环队列的接口

眺愤 8 小时前
目录


目录

  • 目录
  • 队列的概念

    • 假溢出问题

  • 循环队列的实现

    • 1.以数组为基础实现循环队列
    • 2.以链表为基础实现循环队列

  • 两个栈实现队列

队列的概念

队列（Queue）和栈类似，相同点是都属于线性结构，不同点是栈遵循“后进先出”原则，而队列遵循“先进先出”的原则，也被称为“FIFO”结构，就是“First Input First Output”。
数据结构中的队列的两端都允许操作，只不过要求数据只能从队列的一端插入（入队），从队列的另一端删除（出队），可以把队列理解为一根水管，水管有进水口和出水口。一般把允许数据插入的一端称为队尾（Tail或者Rear），一般把允许删除数据的一端称为队头队首（Head或者Front）。
和栈一样，队列也可以通过数组或者链表来实现，通过数组来实现的队列我们称之为“顺序队列”，通过链表实现的队列称之为“链式队列”
假溢出问题

如果使用数据实现简单的队列，当执行多次入队和出队之后，队列的尾指针 Rear 和头指针 Front 已经到达数组的末尾，即使队列中有许多空闲位置（前面的元素删除后就会有位置），也无法再进行入队操作。这种情况被称为 “假溢出”，也就是队列又是空的又是满的，这看起来是一个自相矛盾的事情却在队列里面出现了，如下图所示：
1.png

解决方案：

  • 在学习顺序表（数组）的时候，当顺序表（数组）中删除一个元素，那么这个位置之后的所有元素都需要往前移动一位，所以队列中也是同理，假如我们用数组来实现的话，当元素出队时，我们把所有元素都往前移，不过这样因为每次都需要搬移数据，导致入队的时间复杂度是O(n)
  • 可以把队列设置为循环队列，循环队列也被称为“环形缓冲区”，通过使队列的尾部与头部相连，形成一个闭环，可以使得出队后的空间得到重新利用，从而最大限度地使用数组空间，避免了空间的浪费，在移动数据的时候只需要移一次即可，所以时间复杂度就是O(1)
循环队列的实现

1.以数组为基础实现循环队列
  1. /**
  2. * @file name ： Cirqueue.c
  3. * @brief     :  该程序以数组为基础实现循环队列元素的初始化、入队、出队、遍历，另外为了提高可移植性，所以循环队列中
  4. *               数据元素的类型为DataType_t，用户可以根据实际情况修改循环队列中元素的类型
  5. * @author    :  MINDSETT@163.com
  6. * @date      :  2025/7/5
  7. * @version   :  1.0
  8. * @note      :  以数组末尾浪费一个存储空间为代价来换取更简便的代码
  9. * CopyRight (c)  2025  MINDSETT@163.com  All Right Reserved
  10. */
  12. #include <stdbool.h>
  13. #include <stdlib.h>
  14. #include <stdio.h>
  16. //指定循环队列中的元素的数据类型，用户可根据需要进行修改
  17. typedef int DataType_t;
  19. //构造一个实现循环队列的各项参数（循环队列首地址+循环队列的容量+队尾下标+队首下标）的结构体
  20. typedef struct Circular_Queue
  21. {
  22.     DataType_t *  addr;    //循环队列首地址
  23.     unsigned int  size;      //循环队列的容量
  24.     int           rear;       //队尾下标
  25.     int           front;       //队首下标
  26. }Cirqueue_t;
  29. /**
  30. * @name    :  Cirqueue_Create
  31. * @brief   :  创建一个循环队列并进行初始化
  32. * @param   :  None
  33. * @retval  :  返回栈底地址
  34. * @date    :  2025/7/5
  35. * @version :  1.0
  36. * @note    :  None
  37. */
  38. Cirqueue_t *Cirqueue_Create(unsigned int size)
  39. {
  40.     //1.利用calloc对循环队列的管理结构体申请一个内存
  41.     Cirqueue_t *manager=(Cirqueue_t *)calloc(1,sizeof(Cirqueue_t));
  42.     if (NULL == manager){
  43.         perror("calloc memory for manager is failed\n");
  44.         exit(-1);
  45.     }
  46.     //2.对循环队列管理结构体的所有元素进行初始化
  47.     manager->addr=(DataType_t *)calloc(size,sizeof(DataType_t));
  48.     if (NULL == manager->addr){
  49.         perror("calloc memory for Stack is failed\n");
  50.         exit(-1);
  51.     }
  52.     manager->size=size;
  53.     manager->rear=0;
  54.     manager->front=0;
  55.     return manager;
  56. }
  59. /**
  60. * @name    :  Cirqueue_IsFull
  61. * @brief   :  判断循环队列是否已满
  62. * @param   :  
  63. *              @manager:需要判断的循环队列
  64. * @retval  :  已满返回true，未满返回false
  65. * @date    :  2025/7/5
  66. * @version :  1.0
  67. * @note    :  None
  68. */
  69. bool Cirqueue_IsFull(Cirqueue_t *manager)
  70. {
  71.     return ( ( (manager->rear+1)%manager->size )==manager->front )? true : false;
  72. }
  74. /**
  75. * @name    :  Cirqueue_IsEmpty
  76. * @brief   :  判断循环队列是否为空
  77. * @param   :  
  78. *              @manager:需要判断的循环队列
  79. * @retval  :  为空返回true，不为空返回false
  80. * @date    :  2025/7/5
  81. * @version :  1.0
  82. * @note    :  None
  83. */
  84. bool Cirqueue_IsEmpty(Cirqueue_t *manager)
  85. {
  86.     return (manager->rear==manager->front)? true : false;
  87. }
  89. /**
  90. * @name    :  Cirqueue_Enqueue
  91. * @brief   :  入队
  92. * @param   :  
  93. *              @manager:需要操作的循环队列
  94. *              @Data:需要入队的元素
  95. * @retval  :  已满返回true，未满返回false
  96. * @date    :  2025/7/5
  97. * @version :  1.0
  98. * @note    :  None
  99. */
  100. bool Cirqueue_Enqueue(Cirqueue_t *manager,DataType_t Data)
  101. {
  102.     //判断循环队列是否已满
  103.     if ( Cirqueue_IsFull(manager) ){
  104.         printf("Circular Queue is Full\n");
  105.         return false;
  106.     }
  107.     //如果循环队列有剩余空间，则把新元素插入循环队列的队尾
  108.     manager->addr[manager->rear]=Data;
  109.     //防止队尾下标越界
  110.     manager->rear=(manager->rear+1)%manager->size;
  111.     return true;
  112. }
  116. /**
  117. * @name    :  Cirqueue_Dequeue
  118. * @brief   :  出队
  119. * @param   :  
  120. *              @manager:需要操作的循环队列
  121. * @retval  :  成功返回出队的元素
  122. * @date    :  2025/7/5
  123. * @version :  1.0
  124. * @note    :  None
  125. */
  126. DataType_t Cirqueue_Dequeue(Cirqueue_t *manager)
  127. {   
  128.     //判断循环队列是否为空
  129.     if ( Cirqueue_IsEmpty(manager) ){
  130.         printf("Circular Queue is empty\n");
  131.         return false;
  132.     }
  133.     //定义临时变量存储要出队的元素
  134.     DataType_t temp=0;
  135.     //队首元素出队，队首下标+1
  136.     temp=manager->addr[manager->front];
  137.     //防止队首下标越界
  138.     manager->front=(manager->front+1)%manager->size;
  139.     return temp;
  140. }
  142. /**
  143. * @name    :  Cirqueue_Print
  144. * @brief   :  遍历
  145. * @param   :  
  146. *              @manager:需要操作的循环队列
  147. * @retval  :  成功返回true，失败返回false
  148. * @date    :  2025/7/5
  149. * @version :  1.0
  150. * @note    :  None
  151. */
  152. bool Cirqueue_Print(Cirqueue_t *manager)
  153. {
  154.     if (Cirqueue_IsEmpty(manager)) {
  155.         printf("Circular Queue is empty\n");
  156.         return false;
  157.     }
  158.     int i = manager->front;
  159.     printf("Queue: ");
  160.     while (i != manager->rear) {
  161.         printf("%d ", manager->addr[i]);
  162.         i = (i + 1) % manager->size;
  163.     }
  164.     printf("\n");
  165.     return true;
  166. }
复制代码
2.以链表为基础实现循环队列
  1. /**
  2. * @file name ： CirLnList_Queue.c
  3. * @brief     :  该程序以链表为基础实现循环队列元素的初始化、入队、出队、遍历，另外为了提高可移植性，所以循环队列中
  4. *               数据元素的类型为DataType_t，用户可以根据实际情况修改循环队列中元素的类型
  5. * @author    :  MINDSETT@163.com
  6. * @date      :  2025/7/11
  7. * @version   :  1.0
  8. * @note      :  头结点不存储数据，仅用于管理队列
  9. * CopyRight (c)  2025  MINDSETT@163.com  All Right Reserved
  10. */
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <stdbool.h>
  15. //指定循环队列中元素的数据类型，用户可根据需要进行修改
  16. typedef int DataType_t;
  18. //构造循环队列的结点，循环队列中所有结点的数据类型应该是相同的（数据域+指针域）
  19. typedef struct CircularLinkedList_Queue
  20. {
  21.     DataType_t                  data;   //结点的数据域
  22.     struct CircularLinkedList_Queue *   next;   //结点的指针域
  23. }CirLnList_Queue_t;
  26. /**
  27. * @name    :  Queue_Create
  28. * @brief   :  创建一个空循环队列，空循环队列应该有一个头节点，对循环队列进行初始化
  29. * @param   :  None
  30. * @retval  :  返回头结点的地址
  31. * @date    :  2025/7/11
  32. * @version :  1.0
  33. * @note    :  None
  34. */
  35. CirLnList_Queue_t *Queue_Create(void)
  36. {
  37.     //创建一个头结点并对头结点申请内存
  38.     CirLnList_Queue_t* Head=(CirLnList_Queue_t*)calloc(1,sizeof(CirLnList_Queue_t));
  39.     if (NULL==Head){
  40.         perror("calloc memory for Head is failed\n");
  41.         exit(-1);
  42.     }
  43.     //对头结点进行初始化,头结点不存储数据域，指针域指向自身，体现“循环”思想
  44.     Head->next=Head;
  45.     //将头结点的地址返回
  46.     return Head;
  47. }
  50. /**
  51. * @name    :  Queue_NewNode
  52. * @brief   :  创建一个新结点，并为新结点申请堆内存以及对新结点的数据域和指针域进行初始化
  53. * @param   :  
  54. *             @data:新结点的数据
  55. * @retval  :  返回新结点的地址
  56. * @date    :  2025/7/11
  57. * @version :  1.0
  58. * @note    :  None
  59. */
  60. CirLnList_Queue_t * Queue_NewNode(DataType_t data)
  61. {
  62.     //创建新结点，并未新结点申请堆内存
  63.     CirLnList_Queue_t * New=(CirLnList_Queue_t*)calloc(1,sizeof(CirLnList_Queue_t));
  64.      if (NULL==New){
  65.         perror("calloc memory for NewNode is failed\n");
  66.         return NULL;
  67.     }
  68.     //对新结点的数据域和指针域进行初始化
  69.     New->data=data;
  70.     New->next=NULL;
  71.     return New;
  72. }
  74. /**
  75. * @name    :  Queue_Enqueue
  76. * @brief   :  入队
  77. * @param   :  
  78. *             @Head:插入的循环队列
  79. *             @data:新结点的数据
  80. * @retval  :  成功返回true，失败返回false
  81. * @date    :  2025/7/11
  82. * @version :  1.0
  83. * @note    :  None
  84. */
  85. bool Queue_Enqueue(CirLnList_Queue_t * Head,DataType_t data)
  86. {
  87.     //创建新结点，并对新结点进行初始化
  88.     CirLnList_Queue_t* New=Queue_NewNode(data);
  89.     if (NULL==New){
  90.         perror("Create New node is failed\n");
  91.         return false;
  92.     }
  93.     //判断循环队列是否为空，如果为空，则将新结点直接插入
  94.     if (Head==Head->next){
  95.         Head->next=New;
  96.         New->next=New;//指针域指向自身，体现“循环”思想
  97.         return true;
  98.     }
  99.     //备份首结点的地址
  100.     CirLnList_Queue_t * tail=Head->next;
  101.     //找到尾结点
  102.     while( tail->next != Head->next ){
  103.         tail=tail->next;
  104.     }
  105.     //新结点指向首结点，旧尾结点指向新结点
  106.     New->next=tail->next;
  107.     tail->next=New;
  109.     return true;
  110. }
  112. /**
  113. * @name    :  Queue_Dequeue
  114. * @brief   :  出队
  115. * @param   :  
  116. *             @Head:循环队列的头结点
  117. * @retval  :  成功返回true，失败返回false
  118. * @date    :  2025/7/11
  119. * @version :  1.0
  120. * @note    :  None
  121. */
  122. bool Queue_Dequeue(CirLnList_Queue_t* Head)
  123. {
  124.     //备份首结点
  125.     CirLnList_Queue_t * first=Head->next;
  126.     CirLnList_Queue_t * tail=Head->next;
  127.     //判断传参错误或循环队列为空
  128.     if (NULL==Head || Head==Head->next){
  129.         perror("Linked list is empty\n");
  130.         return false;
  131.     }
  132.     //1.只有一个首结点
  133.     if (Head->next->next==Head->next){
  134.         Head->next=Head;
  135.         first->next=NULL;//首结点的指针域指向NULL,从循环队列中断开(避免野指针)
  136.         free(first);
  137.         return true;
  138.     }
  139.     //2.循环队列有多个结点
  140.     //找到尾结点
  141.     while( tail->next!=Head->next ){
  143.         tail=tail->next;
  144.     }
  145.     //尾结点指向首结点的直接后驱
  146.     tail->next=first->next;
  147.     //将头结点指针域指向首结点的直接后驱
  148.     Head->next=first->next;
  149.     //旧的首结点的指针域指向NULL,从循环队列中断开(避免野指针)
  150.     first->next=NULL;
  151.     //释放首结点占用的内存
  152.     free(first);
  154.     return true;
  155. }
  157. /**
  158. * @name    :  Queue_Print
  159. * @brief   :  遍历输出循环队列中各个结点的数据
  160. * @param   :  
  161. *             @Head:需要遍历的循环队列
  162. * @retval  :  成功返回true，失败返回false
  163. * @date    :  2025/7/11
  164. * @version :  1.0
  165. * @note    :  None
  166. */
  167. bool Queue_Print(CirLnList_Queue_t* Head)
  168. {
  169.     //判断传参错误或循环队列为空
  170.     if (NULL==Head || Head==Head->next){
  171.         perror("Current CircularLinkedList is empty\n");
  172.         return false;
  173.     }
  174.     //对循环队列的头节点的地址进行备份
  175.     CirLnList_Queue_t *curr=Head;
  176.     //循环遍历循环队列
  177.     while(curr->next){
  178.         curr=curr->next;
  179.         printf("Data=%d ",curr->data);
  180.         if( curr->next == Head->next){
  181.             break;
  182.         }
  183.     }
  185.     return true;
  186. }
复制代码
两个栈实现队列

2.png
  1. // 基本思想：利用栈s1和栈s2实现队列，栈的思想是“先进后出”，队列的思想是“先进先出”，可以选择把栈s1作为入队缓存，栈s2作为出队缓存
复制代码
  1. //代码实现：在栈的基础上使用两个栈实现循环队列的入队和出队
  3. /**
  4. * @file name ： Stack_Queue.c
  5. * @brief     :  该程序以栈为基础实现循环队列元素的初始化、入队、出队、遍历，另外为了提高可移植性，所以循环队列中
  6. *               数据元素的类型为DataType_t，用户可以根据实际情况修改循环队列中元素的类型
  7. * @author    :  MINDSETT@163.com
  8. * @date      :  2025/7/5
  9. * @version   :  1.0
  10. * @note      :  None
  11. * CopyRight (c)  2025  MINDSETT@163.com  All Right Reserved
  12. */
  14. #include <stdbool.h>
  15. #include <stdlib.h>
  16. #include <stdio.h>
  18. #define maxSize 10
  20. //指定顺序栈中的元素的数据类型，用户可根据需要进行修改
  21. typedef int DataType_t;
  23. //构造一个实现顺序栈的各项参数（栈底地址+栈容量+栈顶元素的下标）的结构体
  24. typedef struct Sequence_Stack
  25. {
  26.     DataType_t *  bottom;    //栈底地址
  27.     unsigned int  size;      //栈容量
  28.     int           top;       //栈顶元素的下标
  29. }SeqStack_t;
  32. /**
  33. * @name    :  SeqStack_Create
  34. * @brief   :  创建一个顺序栈并进行初始化
  35. * @param   :  None
  36. * @retval  :  返回栈底地址
  37. * @date    :  2025/7/5
  38. * @version :  1.0
  39. * @note    :  None
  40. */
  41. SeqStack_t *SeqStack_Create(unsigned int size)
  42. {
  43.     //1.利用calloc对顺序栈的管理结构体申请一个内存
  44.     SeqStack_t *manager=(SeqStack_t *)calloc(1,sizeof(SeqStack_t));
  45.     if (NULL == manager){
  46.         perror("calloc memory for manager is failed\n");
  47.         exit(-1);
  48.     }
  49.     //2.对顺序栈管理结构体的所有元素进行初始化
  50.     manager->bottom=(DataType_t *)calloc(size,sizeof(DataType_t));
  51.     if (NULL == manager->bottom){
  52.         perror("calloc memory for Stack is failed\n");
  53.         exit(-1);
  54.     }
  55.     manager->size=size;
  56.     manager->top=-1;
  57.     return manager;
  58. }
  61. /**
  62. * @name    :  SeqStack_IsFull
  63. * @brief   :  判断顺序栈是否已满
  64. * @param   :  
  65. *              @manager:需要判断的顺序栈
  66. * @retval  :  已满返回true，未满返回false
  67. * @date    :  2025/7/5
  68. * @version :  1.0
  69. * @note    :  None
  70. */
  71. bool SeqStack_IsFull(SeqStack_t *manager)
  72. {
  73.     return (manager->top+1==manager->size)? true : false;
  74. }
  76. /**
  77. * @name    :  SeqStack_IsEmpty
  78. * @brief   :  判断顺序栈是否为空
  79. * @param   :  
  80. *              @manager:需要判断的顺序栈
  81. * @retval  :  为空返回true，不为空返回false
  82. * @date    :  2025/7/5
  83. * @version :  1.0
  84. * @note    :  None
  85. */
  86. bool SeqStack_IsEmpty(SeqStack_t *manager)
  87. {
  88.     return (-1==manager->top)? true : false;
  89. }
  91. /**
  92. * @name    :  SeqStack_Push
  93. * @brief   :  入栈
  94. * @param   :  
  95. *              @manager:需要操作的顺序栈
  96. *              @Data:需要压入的元素
  97. * @retval  :  成功返回true，失败返回false
  98. * @date    :  2025/7/5
  99. * @version :  1.0
  100. * @note    :  None
  101. */
  102. bool SeqStack_Push(SeqStack_t *manager,DataType_t Data)
  103. {
  104.     //判断顺序栈是否已满
  105.     if ( SeqStack_IsFull(manager) ){
  106.         printf("Sequence Stack is Full\n");
  107.         return false;
  108.     }
  109.     //如果顺序栈有剩余空间，则把新元素插入顺序栈的栈顶，并更新管理结构体中最后栈顶的元素下标
  110.     manager->bottom[++manager->top]=Data;
  111.     return true;
  112. }
  116. /**
  117. * @name    :  SeqStack_Pop
  118. * @brief   :  出栈
  119. * @param   :  
  120. *              @manager:需要操作的顺序栈
  121. *              @out:接收弹出的值
  122. * @retval  :  成功返回true，失败返回false
  123. * @date    :  2025/7/5
  124. * @version :  1.0
  125. * @note    :  None
  126. */
  127. bool SeqStack_Pop(SeqStack_t *manager, DataType_t *out)
  128. {   
  129.     //判断顺序栈是否为空
  130.     if ( SeqStack_IsEmpty(manager) ){
  131.         printf("Sequence Stack is empty\n");
  132.         return false;
  133.     }
  135.     //删除一个元素，栈顶元素下标-1
  136.     *out=manager->bottom[manager->top--];
  138.     return true;
  139. }
  142. /**
  143. * @name    :  SeqStack_print
  144. * @brief   :  遍历顺序栈
  145. * @param   :  
  146. *              @manager:需要操作的顺序栈
  147. * @retval  :  成功返回true，失败返回false
  148. * @date    :  2025/7/5
  149. * @version :  1.0
  150. * @note    :  None
  151. */
  152. void SeqStack_print(SeqStack_t *manager)
  153. {  
  154.      //判断顺序栈是否为空
  155.     if ( SeqStack_IsEmpty(manager) ){
  156.         printf("Sequence Stack is empty\n");
  157.         return;
  158.     }
  159.     //如果顺序栈不为空，则打印顺序栈的元素
  160.     for (int i=0;i<manager->top+1;i++){
  161.         printf("Element[%d]=%d\n",i,manager->bottom[i]);
  162.     }
  163.     printf("\n");
  164. }
  167. /**
  168. * @name    :  Enqueue
  169. * @brief   :  入队
  170. * @param   :  
  171. *              @s1:传入栈s1
  172. *              @s2:传入栈s2
  173. *              @Data：需要入队的数据
  174. * @retval  :  成功返回true，失败返回false
  175. * @date    :  2025/7/5
  176. * @version :  1.0
  177. * @note    :  使用栈s1和栈s2模拟队列，具有“先进先出”的思想
  178. */
  179. bool Enqueue(SeqStack_t *s1,SeqStack_t *s2,DataType_t Data)
  180. {
  181.     DataType_t temp;//用于临时存储栈1出栈到栈2的元素的值
  182.    
  183.     //判断栈1是否已满（已满 OR 未满）
  184.     if(s1->top+1>=maxSize){
  185.         //判断栈2是否为空（空 OR 不空）
  186.         if(SeqStack_IsEmpty(s2)){
  187.             //栈2为空，一次将栈1中的元素出战到栈2
  188.             while(!SeqStack_IsEmpty(s1)){
  189.                 if(!SeqStack_Pop(s1,&temp)) return false;
  190.                 if(!SeqStack_Push(s2,temp)) return false;
  191.             }
  192.             //栈1为空后，将元素插入栈1
  193.             if(!SeqStack_Push(s1,Data)) return false;
  194.             return true;
  195.         }else{
  196.             //栈2不为空，无法入队
  197.             return false;
  198.         }
  199.     }else{
  200.         // 栈1未满，直接将元素插入栈1
  201.         if(!SeqStack_Push(s1,Data)) return false;
  202.     }
  204.     return true;
  205. }
  207. /**
  208. * @name    :  Dequeue
  209. * @brief   :  出队
  210. * @param   :  
  211. *              @s1:传入栈s1
  212. *              @s2:传入栈s2
  213. *              @out：接收出队的数据
  214. * @retval  :  成功返回true，失败返回false
  215. * @date    :  2025/7/5
  216. * @version :  1.0
  217. * @note    :  使用栈s1和栈s2模拟队列，具有“先进先出”的思想
  218. */
  219. bool Dequeue(SeqStack_t *s1,SeqStack_t *s2,DataType_t *out)
  220. {
  221.     DataType_t temp;//用于临时存储栈1出栈到栈2的元素的值
  222.     //判断队列是否为空，即栈1和栈2是否都为空（空 OR 不空）
  223.     if(SeqStack_IsEmpty(s1) && SeqStack_IsEmpty(s2)){
  224.         return false;
  225.     }else{
  226.         //判断栈2是否为空（空 OR 不空）
  227.         if(!SeqStack_IsEmpty(s2)){
  228.             //栈2不为空，直接出栈
  229.             if(!SeqStack_Pop(s2,out)) return false;
  230.         }else{
  231.             //栈2为空，将栈1内的元素一次出栈到栈2
  232.             while(!SeqStack_IsEmpty(s1)){
  233.                 if(!SeqStack_Pop(s1,&temp)) return false;
  234.                 if(!SeqStack_Push(s2,temp)) return false;
  235.             }
  236.             //栈1为空后，将栈2元素出栈
  237.             if(!SeqStack_Pop(s2,out)) return false;
  238.         }
  239.     }
  241.     return true;
  242. }
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
眺愤
8 小时前

0

粉丝关注

13

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫