DAY seven 队列 和 循环队列

代码

#include<stdio.h>
#include<stdlib.h>
 
/**
 *队列结点
 */
 
typedef struct LinkNode{
    int data;
    struct LinkNode *next;
} *LinkNodePtr;
 
/**
 *链队列
 */
 
typedef struct LinkQueue{
    LinkNodePtr front;
    LinkNodePtr rear;
} *LinkQueuePtr; 
 
/**
 *创建一个空队列
 */
 
LinkQueuePtr initQueue() {
    LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
    LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
    headerPtr->next = NULL;
    
    resultPtr->front = headerPtr;
    resultPtr->rear = headerPtr;
    return resultPtr; 
}
 
/**
 *输出
 */
 
void outputLinkQueue(LinkQueuePtr paraQueuePtr) {
    LinkNodePtr tempPtr = paraQueuePtr->front->next;
    
    while (tempPtr != NULL) {
        printf("%d ", tempPtr->data);
        tempPtr = tempPtr->next;
    }
    
    printf("\n");
}
 
/**
 *插入
 */
 
void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
    LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
    tempNodePtr->data = paraElement;
    tempNodePtr->next = NULL;
    
    paraQueuePtr->rear->next = tempNodePtr;
    
    paraQueuePtr->rear = tempNodePtr;
}
 
/**
 *删除
 */
 
int dequeue(LinkQueuePtr paraQueuePtr) {
    int resultValue;
    LinkNodePtr tempNodePtr;
    
    if (paraQueuePtr->front == paraQueuePtr->rear) {
        printf("The queue is empty\n");
        return -1;
    }
    
    tempNodePtr = paraQueuePtr->front->next;
    resultValue = tempNodePtr->data;
    paraQueuePtr->front->next = paraQueuePtr->front->next->next;
    
    if (paraQueuePtr->rear == tempNodePtr) {
        paraQueuePtr->rear = paraQueuePtr->front;
    }
    
    return resultValue;
}
 
void testLinkQueue() {
    LinkQueuePtr tempQueuePtr;
    tempQueuePtr = initQueue();
    enqueue(tempQueuePtr, 10);
    enqueue(tempQueuePtr, 50);
    enqueue(tempQueuePtr, 30);
    
    outputLinkQueue(tempQueuePtr);
    
    printf("dequeue gets %d\n", dequeue(tempQueuePtr));
    printf("dequeue gets %d\n", dequeue(tempQueuePtr));
    printf("dequeue gets %d\n", dequeue(tempQueuePtr));
    printf("dequeue gets %d\n", dequeue(tempQueuePtr));
    
    enqueue(tempQueuePtr, 8);
    outputLinkQueue(tempQueuePtr);
}
 
int main() {
    testLinkQueue();
    return 0;
}

 循坏队列代码

#include<stdio.h>
#include<stdlib.h>
 
/**
 *创建队列
 */
 
typedef struct circleIntQueue{
    int data[5];
    int head;
    int tail;
} *CircleIntQueuePtr;
 
/**
 *初始化
 */
 
CircleIntQueuePtr initQueue() {
    CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct circleIntQueue));
    
    resultPtr->head = 0;
    resultPtr->tail = 0;
    
    return resultPtr;
}
 
/**
 *插入
 */
 
void enqueue(CircleIntQueuePtr paraPtr, int paraValue) {
    if ((paraPtr->tail + 1) % 5 == paraPtr->head) {
        printf("Queue full\n");
        return;
    }
    
    paraPtr->data[paraPtr->tail % 5] = paraValue;
    paraPtr->tail = (paraPtr->tail ++) % 5;
}
 
/**
 *删除
 */
 
int dequeue(CircleIntQueuePtr paraPtr) {
    int resultValue;
    if (paraPtr->head == paraPtr->tail) {
        printf("No element in the queue.\n");
        return -1;
    }
    
    resultValue = paraPtr->data[paraPtr->head % 5];
    paraPtr->head = (paraPtr->head ++) % 5;
    
    return resultValue;
}
 
/**
 *输出
 */
 
void outputLinkQueue(CircleIntQueuePtr paraPtr) {
    int i;
    if (paraPtr->head == paraPtr->tail) {
        printf("Empty queue.\n");
        return;
    }
    
    printf("Elements in the queue:");
    for (i = paraPtr->head; i < paraPtr->tail; i ++) {
        printf("%d, ", paraPtr->data[i % 5]);
    }
    
    printf("\n");
}
 
void testLinkQueue() {
    int i = 10;
    CircleIntQueuePtr tempPtr = initQueue();
    for (; i < 16; i ++) {
        enqueue(tempPtr, i);
    }
    
    outputLinkQueue(tempPtr);
    
    for (i = 0; i < 6; i ++) {
        printf("dequeue gets %d\n", dequeue(tempPtr));
    }
    
    enqueue(tempPtr, 8);
    outputLinkQueue(tempPtr);
}
 
int main() {
    testLinkQueue();
    
    return 0;
}