#include <iostream>
using namespace std;

//定义结点
typedef struct QNode
{
	int data;
	QNode* next;
}QNode, * QueuePtr;
//定义链队
struct LQueue
{
	QNode* front;	//队头结点
	QNode* rear;	//队尾节点;
};
//初始化队列
void Init(LQueue& Q)
{
	Q.front = Q.rear = new QNode;
	Q.front->next = nullptr;
}

//入队列
void enQueue(LQueue& Q)
{
	int n;
	
	cout << "请输入需要添加的元素个数：" << endl;
	cin >> n;
	cout << "请输入需要添加的元素：" << endl;
	for (int i = 0; i < n; i++)
	{
		QueuePtr p = new QNode;
		cin >> p->data;
		p->next = nullptr;
		Q.rear->next = p;
		Q.rear = p;
	}
}
//判断队列是否为空
bool isEmpty(LQueue Q)
{
	if (Q.front->next == nullptr)
		return true;
	return false;
}
//出队列
void deQueue(LQueue& Q)
{
	int n;
	cout << "请输入需要删除的数字个数：" << endl;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		if (isEmpty(Q))
		{
			cout << "队列为空" << endl;
			return;
		}
		QueuePtr p = new QNode;
		p = Q.front->next;
		cout << "已删除元素：" << p->data << endl;
		Q.front->next = p->next;
		delete(p);
	}
}

//遍历队列
void displayQueue(LQueue Q)
{
	QueuePtr p = Q.front->next;
	while (p != nullptr)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
	return;
}

//获取队顶元素
void getHead(LQueue Q)
{
	if (isEmpty(Q))
	{
		cout << "队列为空" << endl;
		return;
	}
	cout << "队顶元素为：" << Q.front->next->data << endl;
}
void clearQueue(LQueue& Q)
{
	QueuePtr p, q;
	p = Q.front->next;
	Q.front->next = nullptr;
	while (p)
	{
		q = p->next;
		delete(p);
		p = q;
	}
	Q.rear = Q.front;
	return;
}
//销毁队列
void destroyQueue(LQueue& Q)
{
	while (Q.front)
	{
		Q.rear = Q.front->next;
		delete(Q.front);
		Q.front = Q.rear;
	}
}
//获取队列长度
void lengthQueue(LQueue Q)
{
	int cnt = 0;
	QueuePtr p = Q.front->next;
	while (p != nullptr)
	{
		cnt++;
		p = p->next;
	}
		
	cout << "队列长度为:" << cnt << endl;
}
//菜单
void menu()
{
	cout << "********1.入队           2.出队*********" << endl;
	cout << "********3.取队顶元素     4.遍历队列*****" << endl;
	cout << "********5.清空队列       6.销毁队列*****" << endl;
	cout << "********7.队列长度       8.退出*********" << endl;
}
int main()
{
	LQueue queue;
	int choice;
	Init(queue);
	while (1)
	{
		menu();
		cin >> choice;
		if (choice == 8)
			break;
		switch (choice)
		{
		case 1:
			enQueue(queue); break;
		case 2:
			deQueue(queue); break;
		case 3:
			getHead(queue); break;
		case 4:
			displayQueue(queue); break;
		case 5:
			clearQueue(queue); break;
		case 6:
			destroyQueue(queue); break;
		case 7:
			lengthQueue(queue); break;
		default:
			break;
		}
	}
	return 0;
}

#include <iostream>
using namespace std;
//链队列
typedef int DataType;
#define Node ElemType

class Node
{
public:
	DataType data;//结点数据域
	ElemType *next;//结点指针域
};//定义一个结点类（链类需要）

class QueueLinkList 
{
public:
	QueueLinkList();				//初始化队列
	~QueueLinkList();				//摧毁队列
	int IsEmpty();					//判断队列是否为空
	void Enqueue(DataType data);	//入队
	void Dequeue();					//出对
	void PrintfQueue();				//打印队列
private:
	ElemType *front;//对头指针
	ElemType *rear;//队尾指针
};

//初始化队列
QueueLinkList::QueueLinkList()
{
	front = new ElemType;//使对头指针指向新创建的结点
	front->data = 0;//为队头指针的数据域赋值
	front->next = NULL;//指向下一个为空
	rear = front;//队头与队尾重合
}

//摧毁队列
QueueLinkList::~QueueLinkList()//析构函数实现
{
	delete front;
}

//判断队列是否为空
int QueueLinkList::IsEmpty()
{
	return front->next == NULL;//下一个指针域为空，数据域没值
}

//入队
void QueueLinkList::Enqueue(DataType data)
{
	ElemType *newNode = new ElemType;//每次入队都要新创一个结点
	newNode->data = data;//为新创建的数据域赋值
	newNode->next = NULL;//然后将下一个指针域置空
	rear->next = newNode;//使队尾指针指向新创建的结点
	rear = newNode;//使新创建的结点成为队尾
}

//出队
void QueueLinkList::Dequeue()
{
	if (front->next == NULL)
	{
		cout << "队为空" << endl;
	}
	ElemType *ptemp = front->next;//先进先出，创建一个新的指针承接第二个位置的指针域
	front->next = ptemp->next;//使指向第二个元素的指针变成指向第三个元素的指针
	delete ptemp;//删除新创建的，然后就完成了对头指针的交接
}

//遍历队列
void QueueLinkList::PrintfQueue()
{
	ElemType *p = front;//使新创建的指向对头
	if (front->next == NULL)
	{
		cout << "队为空" << endl;
		return;
	}
	while (p->next != NULL)
	{
		p = p->next;//逐个指向
		cout << p->data << " ";//逐个输出完成遍历打印
	}
	cout << endl;
}

//测试函数
int main()
{
	QueueLinkList q;//创建对象q
	int i;
	cout << "1.判断队是否为空   2.入队   3.出队   4.打印队   0.退出" << endl;
	do//循环函数加开关函数巧妙完成
	{
		cout << "请输入要执行的操作：";
		cin >> i;
		switch (i)
		{
		case 1:
			if (q.IsEmpty() == 1)
				cout << "空队" << endl;
			else
			{
				cout << "不是空队" << endl;
			}
			break;
		case 2:
			int n;
			cout << "请输入要入队的值(一次只能入一个值哦):";
			cin >> n;
			q.Enqueue(n);
			break;
		case 3:
			q.Dequeue();
			break;
		case 4:
			cout << "打印队列" << endl;
			q.PrintfQueue();
			break;
		default:
			cout << "输入的操作值错误" << endl;
			break;
		}
	} while (i != 0);
	system("pause");
	return 0;
}

链队列的结构：

链队列与单链表相同但与链栈不同的是，链队列需要添加一个头结点，并让头指针始终指向头结点。

入队：

链队列也不需要判断队满。

出队：

链队列队空条件：Q.front==Q.rear （与循环队列形式相同）

需要特别注意的是：需要判断出队元素是否为最后一个元素，若是，则将队尾指针重新赋值， 指向头结点。 （否则尾指针将丢失）

代码如下：

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

#define MAXQSIZE 100
typedef int QElemType;

//链队列的结构
typedef struct QNode
{
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
	QueuePtr front;			//头指针
	QueuePtr rear;			//尾指针
}LinkQueue;

//初始化
void InitQueue(LinkQueue &Q)
{
	Q.front = new QNode;		//创建一个头结点
	Q.rear = Q.front;			//头尾指针都指向头结点
	Q.front->next = NULL;		
}

//入队
int EnQueue(LinkQueue &Q,QElemType e)
{
	//链队列不需要判断队满

	QNode *p = new QNode;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return 1;
}

//出队
int DeQueue(LinkQueue &Q, QElemType &e)
{
	if (Q.rear == Q.front) return 0;   //队空

	QNode *p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (Q.rear == p) Q.rear = Q.front;		//注意：最后一个元素被删， 队尾指针也要指向头结点 
	delete p;
	return 1;
}

//取队头元素
QElemType GetHead(LinkQueue Q)
{
	if (Q.front != Q.rear)			//非空时 取值
		return Q.front->next->data;
}

//遍历输出队列
void printQueue(LinkQueue Q)
{
	printf("队头->");
	QNode *p =Q.front->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("<-队尾\n");
}


int main()
{
	LinkQueue Q;
	int e;
	InitQueue(Q);
	printf("请输入一个要入队的元素（-1表示结束）：");
	scanf("%d", &e);
	while (e != -1)
	{
		EnQueue(Q, e);
		printf("请输入一个要入队的元素（-1表示结束）：");
		scanf("%d", &e);
	}
	printQueue(Q);
	printf("出队测试：");
	DeQueue(Q, e);
	printQueue(Q);

	printf("取队头元素测试：");
	e = GetHead(Q);
	printf("取出的队头元素为：%d\n", e);
}

运行结果：