linux C -- 通用循环队列

头文件voidQueue.h

  1. #ifndef _VOID_QUEUE_H_

  2. #define _VOID_QUEUE_H_

  3.  
  4.  
  5.  

  6. typedef enum{

  7. FALSE = 0,

  8. TRUE

  9. }BOOL;

  10.  

  11. typedef struct myQueue{

  12. void *data; // 数据域

  13. int size; // 数据域的大小

  14. int Front;

  15. int Rear;

  16. int MaxLen; // 队列的最大长度

  17. }voidQueue;

  18.  
  19.  

  20. typedef void (queue_op_t)(void *);

  21. typedef int (queue_cmp_t)(void *, void *);

  22.  
  23.  

  24. BOOL initQueue(voidQueue *pQueue, int size, int maxLen); // 初始化队列

  25. BOOL isFullQueue(voidQueue *pQueue); // 判断队列是否已满

  26. BOOL isEmptyQueue(voidQueue *pQueue);// 判断队列是否已空

  27. BOOL enQueue(voidQueue *pQueue, void *data); // 添加数据

  28. BOOL delQueue(voidQueue *pQueue, void *data); // 获取数据

  29. void traverseQueue(voidQueue *pQueue, queue_op_t * opt); // 遍历队列

  30. void destroyedQueue(voidQueue *pQueue);

  31. int getQueueCount(voidQueue *pQueue); // 得到队列的当前长度

  32.  
  33.  

  34. #endif

实现头文件中的功能

1. 初始化队列

    参数：队列指针

               数据域的大小

               队列的最大长度

   返回值：成功返回值, 失败返回FALSE

循环队列的最后一个项需要为空，不然无法去判断队列是满还是空，所以申请空间时要多申请一个才会得到需要的队列大小

  1. BOOL initQueue(voidQueue *pQueue, int size, int maxLen)

  2. {

  3. pQueue->data = malloc(size * (maxLen+1));

  4. if (NULL == pQueue->data)

  5. {

  6. return FALSE;

  7. }

  8.  

  9. pQueue->Front = 0;

  10. pQueue->Rear = 0;

  11. pQueue->size = size;

  12. pQueue->MaxLen = maxLen + 1;

  13.  

  14. return TRUE;

  15. }


2. 判断队列是否已满

    参数：队列指针
    返回值：已满返回TRUE, 没满返回FALSE

  1. BOOL isFullQueue(voidQueue *pQueue)

  2. {

  3. if(pQueue->Front == (pQueue->Rear + 1) % pQueue->MaxLen)

  4. {

  5. return TRUE;

  6. }

  7. else

  8. {

  9. return FALSE;

  10. }

  11. }


3. 判断队列是否为空

    参数：队列指针
    返回值：已满返回TRUE, 没满返回FALSE

  1. BOOL isEmptyQueue(voidQueue *pQueue)

  2. {

  3. if (pQueue->Front == pQueue->Rear)

  4. {

  5. return TRUE;

  6. }

  7. else

  8. {

  9. return FALSE;

  10. }

  11. }

4. 添加数据

    参数：队列指针

              需要添加的数据

    返回值： 成功返回TRUE，失败返回FALSE

  1. BOOL enQueue(voidQueue *pQueue, void *data)

  2. {

  3. if (isFullQueue(pQueue))

  4. {

  5. return FALSE;

  6. }

  7.  

  8. memcpy(pQueue->data + pQueue->size * pQueue->Rear, data, pQueue->size);

  9. pQueue->Rear = (pQueue->Rear + 1) % pQueue->MaxLen;

  10.  

  11. return TRUE;

  12. }

4. 获取数据

    参数：队列指针

              存储获取数据的指针

    返回值： 成功返回TRUE，失败返回FALSE

  1. BOOL delQueue(voidQueue *pQueue, void *data)

  2. {

  3. if (isEmptyQueue(pQueue))

  4. {

  5. return FALSE;

  6. }

  7.  

  8. memcpy(data, pQueue->data + pQueue->size * pQueue->Front, pQueue->size);

  9. memset(pQueue->data + pQueue->size * pQueue->Front, 0, pQueue->size);

  10. pQueue->Front = (pQueue->Front + 1) % pQueue->MaxLen;

  11.  

  12. return TRUE;

  13. }

5. 遍历队列

    参数：队列指针

               对遍历到的数据域操作的函数指针

    返回值：无

  1. void traverseQueue(voidQueue *pQueue, queue_op_t *opt)

  2. {

  3. if (isEmptyQueue(pQueue))

  4. {

  5. return ;

  6. }

  7.  

  8. int i = pQueue->Front;

  9. printf("queue element start: \n");

  10. while (i % pQueue->MaxLen != pQueue->Rear)

  11. {

  12. opt(pQueue->data + (i % pQueue->MaxLen) * pQueue->size);

  13. i++;

  14. }

  15.  

  16. printf("traverse end\n");

  17. }


6. 得到队列的当前长度

    参数：队列指针

    返回值：队列的长度

  1. int getQueueCount(voidQueue *pQueue)

  2. {

  3. int count = 0;

  4.  

  5. if (isEmptyQueue(pQueue))

  6. {

  7. return count;

  8. }

  9.  

  10. int i = pQueue->Front;

  11. while (i % pQueue->MaxLen != pQueue->Rear)

  12. {

  13. i++;

  14. count++;

  15. }

  16.  

  17. return count;

  18. }

7. 销毁队列

    参数：队列指针

   返回值：无

  1. void destroyedQueue(voidQueue *pQueue)

  2. {

  3. if (NULL != pQueue->data)

  4. {

  5. free(pQueue->data);

  6. pQueue->data = NULL;

  7. }

  8. }

voidQueue.c

  1. #include <stdio.h>

  2. #include <string.h>

  3. #include <stdlib.h>

  4. #include "voidQueue.h"

  5.  

  6. BOOL initQueue(voidQueue *pQueue, int size, int maxLen)

  7. {

  8. pQueue->data = malloc(size * (maxLen+1));

  9. if (NULL == pQueue->data)

  10. {

  11. return FALSE;

  12. }

  13.  

  14. pQueue->Front = 0;

  15. pQueue->Rear = 0;

  16. pQueue->size = size;

  17. pQueue->MaxLen = maxLen + 1;

  18.  

  19. return TRUE;

  20. }

  21.  
  22.  

  23. BOOL isFullQueue(voidQueue *pQueue)

  24. {

  25. if(pQueue->Front == (pQueue->Rear + 1) % pQueue->MaxLen)

  26. {

  27. return TRUE;

  28. }

  29. else

  30. {

  31. return FALSE;

  32. }

  33. }

  34.  

  35. BOOL isEmptyQueue(voidQueue *pQueue)

  36. {

  37. if (pQueue->Front == pQueue->Rear)

  38. {

  39. return TRUE;

  40. }

  41. else

  42. {

  43. return FALSE;

  44. }

  45. }

  46.  

  47. BOOL enQueue(voidQueue *pQueue, void *data)

  48. {

  49. if (isFullQueue(pQueue))

  50. {

  51. return FALSE;

  52. }

  53.  

  54. memcpy(pQueue->data + pQueue->size * pQueue->Rear, data, pQueue->size);

  55. pQueue->Rear = (pQueue->Rear + 1) % pQueue->MaxLen;

  56.  

  57. return TRUE;

  58. }

  59.  

  60. BOOL delQueue(voidQueue *pQueue, void *data)

  61. {

  62. if (isEmptyQueue(pQueue))

  63. {

  64. return FALSE;

  65. }

  66.  

  67. memcpy(data, pQueue->data + pQueue->size * pQueue->Front, pQueue->size);

  68. memset(pQueue->data + pQueue->size * pQueue->Front, 0, pQueue->size);

  69. pQueue->Front = (pQueue->Front + 1) % pQueue->MaxLen;

  70.  

  71. return TRUE;

  72. }

  73.  

  74. void traverseQueue(voidQueue *pQueue, queue_op_t *opt)

  75. {

  76. if (isEmptyQueue(pQueue))

  77. {

  78. return ;

  79. }

  80.  

  81. int i = pQueue->Front;

  82. printf("queue element start: \n");

  83. while (i % pQueue->MaxLen != pQueue->Rear)

  84. {

  85. opt(pQueue->data + (i % pQueue->MaxLen) * pQueue->size);

  86. i++;

  87. }

  88.  

  89. printf("traverse end\n");

  90. }

  91.  

  92. int getQueueCount(voidQueue *pQueue)

  93. {

  94. int count = 0;

  95.  

  96. if (isEmptyQueue(pQueue))

  97. {

  98. return count;

  99. }

  100.  

  101. int i = pQueue->Front;

  102. while (i % pQueue->MaxLen != pQueue->Rear)

  103. {

  104. i++;

  105. count++;

  106. }

  107.  

  108. return count;

  109. }

  110.  

  111. void destroyedQueue(voidQueue *pQueue)

  112. {

  113. if (NULL != pQueue->data)

  114. {

  115. free(pQueue->data);

  116. pQueue->data = NULL;

  117. }

  118. }

8. 实例测试 main.c

  1. #include <stdio.h>

  2. #include "voidQueue.h"

  3.  

  4. void printQueueData(void *data)

  5. {

  6. int *temp = (int *)data;

  7.  

  8. printf("queue: %d\n", *temp);

  9. }

  10.  

  11. int main(void)

  12. {

  13. voidQueue testQueue;

  14.  

  15. initQueue(&testQueue, sizeof(int), 5);

  16. int ret = isEmptyQueue(&testQueue);

  17. if (ret)

  18. {

  19. printf("11 testQueue is empty\n");

  20. }

  21.  

  22. int addElement;

  23.  

  24. addElement = 1;

  25. enQueue(&testQueue, &addElement);

  26.  

  27. addElement = 2;

  28. enQueue(&testQueue, &addElement);

  29.  

  30. addElement = 3;

  31. enQueue(&testQueue, &addElement);

  32.  

  33. traverseQueue(&testQueue, printQueueData);

  34. printf("queue count: %d\n", getQueueCount(&testQueue));

  35.  

  36. printf("++++++++++++++++++++++++++++++++++++++++++++++++\n");

  37. int delElement;

  38. if (delQueue(&testQueue, &delElement))

  39. {

  40. printf("delElement: %d\n", delElement);

  41. }

  42. else

  43. {

  44. printf("queue is already empty\n");

  45. }

  46.  

  47. if (delQueue(&testQueue, &delElement))

  48. {

  49. printf("delElement: %d\n", delElement);

  50. }

  51. else

  52. {

  53. printf("queue is already empty\n");

  54. }

  55.  

  56. if (delQueue(&testQueue, &delElement))

  57. {

  58. printf("delElement: %d\n", delElement);

  59. }

  60. else

  61. {

  62. printf("queue is already empty\n");

  63. }

  64.  

  65. if (delQueue(&testQueue, &delElement))

  66. {

  67. printf("delElement: %d\n", delElement);

  68. }

  69. else

  70. {

  71. printf("queue is already empty\n");

  72. }

  73.  

  74. printf("------------------------------------------------\n");

  75. addElement = 1;

  76. enQueue(&testQueue, &addElement);

  77.  

  78. addElement = 2;

  79. enQueue(&testQueue, &addElement);

  80.  

  81. addElement = 3;

  82. enQueue(&testQueue, &addElement);

  83.  

  84. addElement = 4;

  85. enQueue(&testQueue, &addElement);

  86.  

  87. addElement = 5;

  88. enQueue(&testQueue, &addElement);

  89.  

  90. addElement = 6;

  91. enQueue(&testQueue, &addElement);

  92.  

  93. traverseQueue(&testQueue, printQueueData);

  94. printf("queue count: %d\n", getQueueCount(&testQueue));

  95.  

  96. printf("====================================================\n");

  97. if (delQueue(&testQueue, &delElement))

  98. {

  99. printf("delElement: %d\n", delElement);

  100. }

  101. else

  102. {

  103. printf("queue is already empty\n");

  104. }

  105.  

  106. if (delQueue(&testQueue, &delElement))

  107. {

  108. printf("delElement: %d\n", delElement);

  109. }

  110. else

  111. {

  112. printf("queue is already empty\n");

  113. }

  114.  

  115. printf("*****************************************************\n");

  116.  

  117. addElement = 9;

  118. enQueue(&testQueue, &addElement);

  119.  

  120. traverseQueue(&testQueue, printQueueData);

  121. printf("queue count: %d\n", getQueueCount(&testQueue));

  122.  

  123. destroyedQueue(&testQueue);

  124.  

  125. printf("Hello World!\n");

  126. return 0;

  127. }

linux C -- 通用循环队列

相关文章：

  • 2021-08-07
  • 2022-12-23
  • 2022-12-23
  • 2022-12-23
  • 2022-12-23
  • 2022-12-23
  • 2021-09-23
猜你喜欢
  • 2022-12-23
  • 2022-12-23
  • 2021-08-12
  • 2022-12-23
  • 2021-11-26
  • 2021-06-06
  • 2021-04-16
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode