数据结构：循环队列

professor's code:

#include <stdio.h>
#include <malloc.h>

#define TOTAL_SPACE 5

/**
 * Circle int queue.
 */
typedef struct CircleIntQueue{
    int data[TOTAL_SPACE];

    int head;

    int tail;
}*CircleIntQueuePtr;

/**
 * Initialize the queue.
 */
CircleIntQueuePtr initQueue() {
    CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
    resultPtr->head = 0;
    resultPtr->tail = 0;

    return resultPtr;
}// Of the first constructor

/**
 * Enqueue.
 * 
 * @param paraValue The value of the new node.
 */
void enqueue(CircleIntQueuePtr paraPtr, int paraValue) {
    if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) {
        printf("Queue full.\r\n");
        return;
    } // Of if

    paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
    paraPtr->tail++;
}// Of enqueue

/**
 * Dequeue.
 * 
 * @return The value at the head.
 */
int dequeue(CircleIntQueuePtr paraPtr) {
    int resultValue;
    if (paraPtr->head == paraPtr->tail) {
        printf("No element in the queue.\r\n");
        return -1;
    } // Of if

    resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
    paraPtr->head++;

    return resultValue;
}// Of dequeue

/**
 * Output the queue.
 */
void outputLinkQueue(CircleIntQueuePtr paraPtr){
    int i;
    if (paraPtr->head == paraPtr->tail) {
        printf("Empty queue.");
        return;
    } // Of if

    printf("Elements in the queue: ");
    for (i = paraPtr->head; i < paraPtr->tail; i++) {
        printf("%d, ", paraPtr->data[i % TOTAL_SPACE]);
    } // Of for i

    printf("\r\n");
}//Of outputLinkQueue

/**
 * Unit test.
 */
void testLinkQueue(){
    int i = 10;
    CircleIntQueuePtr tempPtr = initQueue();
    for (; i < 16; i ++) {
        enqueue(tempPtr, i);
    }//Of for i

    outputLinkQueue(tempPtr);

    for (i = 0; i < 6; i ++) {
        printf("dequeue gets %d\r\n", dequeue(tempPtr));
    }//Of for i

    enqueue(tempPtr, 8);
    outputLinkQueue(tempPtr);
}//Of testLinkQueue

/**
 * The entrance.
 */
int main(){
    testLinkQueue();
    return 1;
}//Of main
---------------------------------------------------------------------------------------------------------------------------------

my code:

 

处理队满、队空有两种方法

1.少用一个空间元素，即队列空间大小为MAX_SIZE时，有MAX_SIZE-1个元素就认为是队满。所以，在循环队列中判断队满和队空的条件是：
队满：(rear + 1) % MAX_SIZE == front
队空：rear == front
2.单独设置一个标识位以便区别队列是否是满状态或空状态。思路：用一个变量 size 来保存当前队列中的元素个数，如果 size == MAX_SIZE，则表示队满；如果 size == 0 则队空

计算公式为：size=(rear - front + MAX_SIZE) % MAX_SIZE

使用第一种方法对图2中的步骤（c）和步骤（e）进行判满处理

 

#include<stdio.h>
#include<malloc.h>
#define max_size 5

typedef struct circlequeue
{
    int data[max_size];
    int head;
    int tail;
}cq,*cqptr;

cqptr init()
{
    cqptr p=(cqptr)malloc(sizeof(cq));
    p->head = 0;
    p->tail = 0;
    return p;
}

void enqueue(cqptr p,int value)
{
    if (p->head == (p->tail + 1) % max_size)
    {
        printf("queue id full\n");
        return;
    }
    p->data[p->tail % max_size] = value;
    p->tail++;
}

void print(cqptr p)
{
    if (p->head == p->tail)
    {
        printf("queue is empty\n");
        return;
    }
    for (int i = p->head; i < p->tail; i++)
    {
        printf("%d ", p->data[i % max_size]);
    }
    printf("\n");
}

void dequeue(cqptr p)
{
    if (p->head == p->tail)
    {
        printf("queue is empty\n");
        return;
    }
    p->head++;
}

int main()
{
    int i;
    cqptr p = init();
    for (i = 0; i < 5; i++)
    {
        enqueue(p,i);
        print(p);
    }
    for (i = 0; i < 4; i++)
    {
        dequeue(p);
        print(p);
    }
    return 0;
}