1. // 判空时用 count 记录
    2. typedef struct {
    3.     int *pdata;
    4.     int head;
    5.     int tail;
    6.     int size;
    7.     int count;
    8. } MyCircularQueue;
    9. MyCircularQueue* myCircularQueueCreate(int k) {
    10.     if (k <= 0) {
    11.         return NULL;
    12.     }
    13.     MyCircularQueue* queue = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    14.     if (!queue) {
    15.         return NULL;
    16.     }
    17.     queue->pdata = (int *)malloc(sizeof(int) * k);
    18.     queue->head = 0;
    19.     queue->tail = 0;
    20.     queue->size = k;
    21.     queue->count = 0;
    22.     for (int i = 0; i < k; i++) {
    23.         queue->pdata[i] = -1;
    24.     }
    25.     return queue; 
    26. }
    27. bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    28.     return obj->count == 0;
    29. }
    31. bool myCircularQueueIsFull(MyCircularQueue* obj) {
    32.     return obj->count == obj->size;
    33. }
    34. bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    35.     if (myCircularQueueIsFull(obj))
    36.         return false;
    38.     obj->pdata[obj->tail] = value;
    39.     obj->tail = (obj->tail + 1) % obj->size;
    40.     obj->count++;
    41.     return true;
    42. }
    43. bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    44.     if (myCircularQueueIsEmpty(obj)) {
    45.         return false;
    46.     }
    47.     obj->pdata[obj->head] = -1;
    48.     obj->head = (obj->head + 1) % obj->size;
    49.     obj->count--;
    50.     return true;
    51. }
    52. int myCircularQueueFront(MyCircularQueue* obj) {
    53.     return  obj->pdata[(obj->head) % obj->size];
    54. }
    55. int myCircularQueueRear(MyCircularQueue* obj) { // 当队列为空时，取尾结点，tail-1为负，所以加上一个size 长度
    56.     return  obj->pdata[(obj->tail - 1 + obj->size) % obj->size]; // -1 是因为tail 指向的是该填入的位置
    57. }
    58. void myCircularQueueFree(MyCircularQueue* obj) {
    59.     free(obj->pdata);
    60.     free(obj);
    61. }
    64. ## 不用 count , 就是多申请了一块内存，判空的方式不同，其他的完全一样
    65. MyCircularQueue* myCircularQueueCreate(int k) {
    66.     if (k <= 0) {
    67.         return NULL;
    68.     }
    69.     MyCircularQueue* queue = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    70.     if (!queue) {
    71.         return NULL;
    72.     }
    73.     queue->pdata = (int *)malloc(sizeof(int) * (k + 1));
    74.     queue->head = 0;
    75.     queue->tail = 0;
    76.     queue->size = k + 1;
    77.     //queue->count = 0;
    78.     for (int i = 0; i < k + 1; i++) {
    79.         queue->pdata[i] = -1;
    80.     }
    81.     return queue; 
    82. }
    84. bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    85.     return obj->head == obj->tail;
    86. }
    88. bool myCircularQueueIsFull(MyCircularQueue* obj) {
    89.     return obj->head == (obj->tail + 1) % obj->size;
    90. }