【C语言】队列的基本操作实现

本次以顺序队列和链式队列的方法实现队列的基本操作

基本操作：初始化，销毁，入队列，出队列，取队头元素

顺序队列：

listqueue.h

#include<stdio.h>
typedef char ListQueueType;
#define MaxSize 1000
typedef struct ListQueue{
ListQueueType data[MaxSize];
size_t size;
size_t head;
size_t tail;
}ListQueue;
void ListQueueInit(ListQueue* Q);//初始化
void ListQueueDestroy(ListQueue* Q);//销毁
void ListQueuePush(ListQueue* Q, ListQueueType value);//入队列
void ListQueuePop(ListQueue* Q);//出队列

int ListQueueTop(ListQueue* Q, ListQueueType value);//取队头元素

listqueue.h

#include "Listqueue.h"
void ListQueueInit(ListQueue* Q)
{
if (Q == NULL){
//非法输入
return;
}
Q->head = 0;
Q->tail = 0;
Q->size = 0;
}
void  ListQueueDestroy(ListQueue* Q)
{
if (Q == NULL){
//非法输入
return;
}
Q->head = 0;
Q->tail = 0;
Q->size = 0;
}
void ListQueuePush(ListQueue* Q, ListQueueType value)
{
if (Q == NULL){
return;
}
if (Q->size >= MaxSize){
return 0;
}
Q->data[Q->tail++] = value;//以尾插的方式入队列，最后一个元素为队首
Q->size++;
Q->tail %= MaxSize;//若队列满了，Q->tail往前移
return;
}
void ListQueuePop(ListQueue* Q)
{
if (Q == NULL){
return;
}
if (Q->size == 0){
return;
}
--Q->size;
}
int ListQueueTop(ListQueue* Q, ListQueueType* value)
{
if (Q == NULL){
return 0;
}
if (Q->size == 0){
return 0;
}
*value = Q->data[Q->head];
return 1;
}
测试代码/
#define TestHeader printf("\n==========================%s=================\n",__FUNCTION__)
void ListQueuePrint(ListQueue* Q, const char* msg){
if (Q == NULL || msg == NULL){
//非法输入
return;
}
printf("[%s]\n", msg);
size_t i = 0;
for (; i < Q->size; i++){
printf("[%c]\n", Q->data[i]);
}
}
void TestInit(){
TestHeader;
ListQueue Q;
ListQueueInit(&Q);
ListQueuePrint(&Q, "对顺序队列进行初始化");
}
void TestPush(){
TestHeader;
ListQueue Q;
ListQueueInit(&Q);
ListQueuePush(&Q, 'a');
ListQueuePush(&Q, 'b');
ListQueuePush(&Q, 'c');
ListQueuePush(&Q, 'd');
ListQueuePrint(&Q, "入队列四个元素");
}
void TestPop(){
TestHeader;
ListQueue Q;
ListQueueInit(&Q);
ListQueuePush(&Q, 'a');
ListQueuePush(&Q, 'b');
ListQueuePush(&Q, 'c');
ListQueuePush(&Q, 'd');
ListQueuePop(&Q);
ListQueuePrint(&Q, "元素d出队列");
}
void TestTop(){
TestHeader;
ListQueue Q;
ListQueueInit(&Q);
ListQueuePush(&Q, 'a');
ListQueuePush(&Q, 'b');
ListQueuePush(&Q, 'c');
ListQueuePush(&Q, 'd');
char tmp;
int ret = ListQueueTop(&Q, &tmp);
printf("expect 1,actual %d\n", ret);
printf("expect a,actual %c\n", tmp);
}
void TestDestroy(){
TestHeader;
ListQueue Q;
ListQueueInit(&Q);
ListQueuePush(&Q, 'a');
ListQueuePush(&Q, 'b');
ListQueuePush(&Q, 'c');
ListQueuePush(&Q, 'd');
ListQueueDestroy(&Q);
ListQueuePrint(&Q, "销毁队列");
}
int main(){
TestInit();
TestPush();
TestPop();
TestTop();
TestDestroy();
return 0;

}

链式队列

linkqueue.h

#include <stdio.h>
#include<stdlib.h>

typedef char LinkQueueType;


typedef struct LinkQueueNode{
LinkQueueType data;
struct LinkQueueNode* next;
}LinkQueueNode;


typedef struct LinkQueue{
LinkQueueNode* head;
LinkQueueNode* tail;
}LinkQueue;


void LinkQueueInit(LinkQueue* q);//初始化
void LinkQueuePush(LinkQueue* q, LinkQueueType value);//入队列
void LinkQueuePop(LinkQueue* q);//出队列
int LinkQueueTop(LinkQueue* q, LinkQueueType* value);//取队首元素

void LinkQueueDestroy(LinkQueue* q);//销毁

LinkQueue.c

#include "LinkQueue.h"
void LinkQueueInit(LinkQueue* q)
{
if (q == NULL){
return;
}
q->head = NULL;
q->tail = NULL;
}
LinkQueue* CreatNode(LinkQueueType value){
LinkQueueNode* New_Node = (LinkQueue*)malloc(sizeof(LinkQueue));
New_Node->data = value;
New_Node->next = NULL;
return New_Node;
}
void LinkQueuePush(LinkQueue*q, LinkQueueType value)
{
if (q == NULL){
return;
}
LinkQueueNode* New_Node = CreatNode(value);
if (q->tail == NULL){
q->head = q->tail = New_Node;
}
else{
q->tail->next = New_Node;
q->tail = q->tail->next;
return;
}
}
void LinkQueuePop(LinkQueue* q)
{
if (q == NULL){
return;
}
if (q->head == NULL){
return;
}
LinkQueueNode* to_delete = q->head;
q->head = q->head->next;
free(to_delete);
}
int LinkQueueTop(LinkQueue* q, LinkQueueType* value)
{
if (q == NULL){
//非法输入
return 0;
}
if (value == NULL || q->head == NULL){
return 0;
}
*value = q->head->data;
return 1;
}
void LinkQueueDestroy(LinkQueue* q)
{
if (q == NULL){
return;
}
do{
LinkQueuePop(q);
} while (q->head != NULL);
return;
}
///测试代码/
#define TestHeader printf("\n======================%s=====================\n",__FUNCTION__)
void LinkQueuePrint(LinkQueue* q, const char* msg){
if (q == NULL){
return;
}
printf("[%s]\n", msg);
printf("[队头]");
LinkQueueNode* cur = q->head;
for (; cur != NULL; cur = cur->next){
printf(" [%c] ", cur->data);
}
printf("[队尾]\n");
return;
}


void TestInit(){
TestHeader;
LinkQueue q;
LinkQueueInit(&q);
LinkQueuePrint(&q, "对栈式队列进行初始化");
}
void TestQueuePush(){
TestHeader;
LinkQueue q;
LinkQueueInit(&q);
LinkQueuePush(&q, 'a');
LinkQueuePush(&q, 'b');
LinkQueuePush(&q, 'c');
LinkQueuePush(&q, 'd');
LinkQueuePrint(&q, "入队列四个元素");
}
void TestQueuePop(){
TestHeader;
LinkQueue q;
LinkQueueInit(&q);
LinkQueuePush(&q, 'a');
LinkQueuePush(&q, 'b');
LinkQueuePush(&q, 'c');
LinkQueuePush(&q, 'd');
LinkQueuePrint(&q, "入队列四个元素");
LinkQueuePop(&q);
LinkQueuePop(&q);
LinkQueuePrint(&q, "出队列两个元素");
}
void TestQueueTop(){
TestHeader;
LinkQueue q;
LinkQueueInit(&q);
LinkQueuePush(&q, 'a');
LinkQueuePush(&q, 'b');
LinkQueuePush(&q, 'c');
LinkQueuePush(&q, 'd');
LinkQueuePrint(&q, "入队列四个元素");
char tmp;
int ret=LinkQueueTop(&q, &tmp);
printf("expect 1,actual %d\n", ret);
printf("enpect a,actual %c", tmp);
}
void TestQueueDestroy(){
TestHeader;
LinkQueue q;
LinkQueueInit(&q);
LinkQueuePush(&q, 'a');
LinkQueuePush(&q, 'b');
LinkQueuePush(&q, 'c');
LinkQueuePush(&q, 'd');
LinkQueuePrint(&q, "入队列四个元素");
LinkQueueDestroy(&q);
LinkQueuePrint(&q,"销毁队列");


}
int main(){
TestInit();
TestQueuePush();
TestQueuePop();
TestQueueTop();
TestQueueDestroy();
return 0;
}