队列的链式存储结构C代码实现

队列的抽象数据类型

	ADT 队列（Queue）
	Data 
		同线性表。元素具有相同的类型，相邻元素具有前驱和后继的关系
	Operator
		InitQueue(*Q):初始化操作，建立一个空队列Q
		DestroyQueue(*Q):若队列存在则销毁他
		ClearQueue(*Q):将队列清空
		QueueEmpty(Q):若队列为空，返回true。否则返回false
		GetHead(Q,*e):若队列存在且非空，用e返回队列Q的队头元素
		EnQueue(*Q,e):若队列存在，插入新元素e到队列Q中并成为队尾元素。
		DeQueue(*Q,*e):删除队列Q中对头元素，并用e返回其值
		QueueLength(Q):返回队列的元素个数
	endADT

test.hpp

#ifndef TEST_H_
#define TEST_H_
#include"malloc.h"
typedef int QElemtype;

typedef struct QNode
{
	QElemtype data;
	struct QNode * next;
}QNode,*QueuePtr;

typedef struct 
{
	QueuePtr front, rear;
}LinkQueue;

//InitQueue(*Q) :初始化操作，建立一个空队列Q
LinkQueue * initQueue();
//DestroyQueue(*Q) : 若队列存在则销毁他
void destroyQueue(LinkQueue * Q);
//ClearQueue(*Q) : 将队列清空
void clearQueue(LinkQueue * Q);
//QueueEmpty(Q) : 若队列为空，返回true。否则返回false
bool queueEmpty(const LinkQueue Q);
//GetHead(Q, *e) : 若队列存在且非空，用e返回队列Q的队头元素
void getHead(LinkQueue Q, QElemtype * e);
//EnQueue(*Q, e) : 若队列存在，插入新元素e到队列Q中并成为队尾元素。
void enQueue(LinkQueue * Q, const QElemtype e);
//DeQueue(*Q, *e) : 删除队列Q中对头元素，并用e返回其值
void deQueue(LinkQueue * Q, QElemtype * e);
//QueueLength(Q) : 返回队列的元素个数
int QueueLength(LinkQueue Q);
#endif // !TEST_H_

#pragma once

test.cpp

#include"test.h"

//InitQueue(*Q) :初始化操作，建立一个空队列Q
LinkQueue * initQueue() {

	LinkQueue * temp = (LinkQueue *)malloc(sizeof(LinkQueue));
	temp->front = temp->rear = (QueuePtr)malloc(sizeof(QNode));
	//temp->front = nullptr;
	return temp;
}

//DestroyQueue(*Q) : 若队列存在则销毁他
void destroyQueue(LinkQueue * Q) {

	if (Q->front != nullptr)
		free(Q);

}

//ClearQueue(*Q) : 将队列清空
/*
		
	}
	return j;
*/
void clearQueue(LinkQueue * Q) {

	if (Q->front == Q->rear)
		return;

	QueuePtr p = Q->front->next;
	QueuePtr q;

	while (p->next != nullptr)
	{
		q = p->next;
		free(p);
		p = q;
	}
	Q->front = Q->rear;

}

//QueueEmpty(Q) : 若队列为空，返回true。否则返回false
bool queueEmpty(const LinkQueue Q) {

	if (Q.rear == Q.front)
		return true;
	else
		return false;
}

//GetHead(Q, *e) : 若队列存在且非空，用e返回队列Q的队头元素
void getHead(LinkQueue Q, QElemtype * e) {

	*e = Q.front->next->data;

}

//EnQueue(*Q, e) : 若队列存在，插入新元素e到队列Q中并成为队尾元素。
void enQueue(LinkQueue * Q, const QElemtype e) {
	 
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if (!s)
		return;
	s->data = e;
	s->next = nullptr;
	Q->rear->next = s;
	Q->rear = s;
}

//DeQueue(*Q, *e) : 删除队列Q中对头元素，并用e返回其值
void deQueue(LinkQueue * Q, QElemtype * e) {

	if (Q->front == Q->rear)
		return;
	QueuePtr p = Q->front->next;
	*e = p->data;
	Q->front->next = p->next;

	if (Q->rear == p)
		Q->rear = Q->front;
	free(p);

}

//QueueLength(Q) : 返回队列的元素个数
int QueueLength(LinkQueue Q) {

	if (Q.front == Q.rear)
		return 0;

	QueuePtr p = Q.front->next;
	QueuePtr q;
	int j = 1;
	while (p->next != nullptr)
	{
		j++;
		q = p->next;
		p = q;
	}
	return j;
}

main.cpp

#include<iostream>
#include"test.h"
void showQueue(const LinkQueue Q);
int main()
{
	LinkQueue *root = initQueue();
	std::cout << "队列是否为空： " <<queueEmpty(*root) <<std::endl;
	std::cout << "队列的长度为： " << QueueLength(*root) << std::endl;
	showQueue(*root);
	enQueue(root, 1);
	enQueue(root, 2);
	enQueue(root, 3);
	enQueue(root, 4);
	enQueue(root, 5);
	enQueue(root, 6);
	enQueue(root, 7);
	enQueue(root, 8);
	std::cout << "队列是否为空： " << queueEmpty(*root) << std::endl;
	std::cout << "队列的长度为： " << QueueLength(*root) << std::endl;
	showQueue(*root);
	int e;
	deQueue(root,&e);
	std::cout << "出队元素为： " << e << std::endl;
	std::cout << "队列是否为空： " << queueEmpty(*root) << std::endl;
	std::cout << "队列的长度为： " << QueueLength(*root) << std::endl;
	showQueue(*root);
	clearQueue(root);
	std::cout << "队列是否为空： " << queueEmpty(*root) << std::endl;
	std::cout << "队列的长度为： " << QueueLength(*root) << std::endl;
	showQueue(*root);
	return 0;
}

void showQueue(const LinkQueue Q) {

	if (Q.front == Q.rear)
	{
		std::cerr << "空队列\n";
		return;
	}
	
	QueuePtr p = Q.front->next;
	QueuePtr q;
	while (p->next != nullptr)
	{
		std::cout << p->data << " " ;
		q = p->next;
		p = q;
	}
	std::cout << p->data << " ";
	std::cout << std::endl;
}

运行结果：