队列 C底层实现

顺序队列 循环队列 链式队列 C底层实现

---

前言

在初学数据结构的过程中，很有必要不借助STL库函数来实现队列的内部结构，这更方便我们打好队列的基础。下面的程序均使用C实现，更加适合数据结构的初学者。

一.顺序队列

Queue.h：

#pragma once
#include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
#define MAX 5
typedef int bool;
typedef int ElemType;
typedef struct {
	ElemType data[MAX];
	int front, rear;
}Queue;

//初始化队列
void InitQueue(Queue *Q);
//判断队列是否为空
bool Empty(Queue Q);
//判断队列是否为满
bool Full(Queue Q);
//入队
bool EnQueue(Queue *Q, ElemType e);
//出队
bool DeQueue(Queue *Q, ElemType *e);
//读队头元素
bool GetHead(Queue Q, ElemType *e);

Queue.c：

#include "Queue.h"


//初始化队列
/*
注意队列的front==rear时表示队列为空,rear表示指向下一个即将入队的位置
在写到入队出队操作时发现 ，其实顺序队列没有太大的意义，因为队列资源用一个少一个，根本没有循环队列实用
*/
void InitQueue(Queue *Q) {
	Q->front = 0;
	Q->rear = 0;
}

//判断队列是否为空
bool Empty(Queue Q) {
	if (Q.front == Q.rear)
		return true;
	else
		return false;
}

//判断队列是否为满
bool Full(Queue Q) {
	if (Q.rear == MAX)
		return true;
	else
		return false;
}

//入队
bool EnQueue(Queue *Q, ElemType e) {
	if (Full(*Q))
		return false;
	Q->data[Q->rear++] = e;
	return true;
}

//出队
bool DeQueue(Queue *Q, ElemType *e) {
	if (Empty(*Q))
		return false;
	*e = Q->data[Q->front++];
	return true;
}

//读队头元素
bool GetHead(Queue Q, ElemType *e) {
	if (Empty(Q))
		return false;
	*e = Q.data[Q.front];
	return true;
}

main.c：

#include "Queue.h"

int main()
{
	Queue Q;
	InitQueue(&Q);
	EnQueue(&Q, 1);
	EnQueue(&Q, 2);
	EnQueue(&Q, 3);
	ElemType e;
	GetHead(Q, &e);
	printf("data[front] = %d\n", e);
	return 0;
}

二.循环队列

CycleQueue.h:

#pragma once
#include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
#define MAX 5
typedef int bool;
typedef int ElemType;
typedef struct {
	ElemType data[MAX];
	int front, rear;
}Queue;

//初始化队列
void InitQueue(Queue *Q);
//判断队列是否为空
bool Empty(Queue Q);
//判断队列是否为满
bool Full(Queue Q);
//求队列长度
int Length(Queue Q);
//入队
bool EnQueue(Queue *Q, ElemType e);
//出队
bool DeQueue(Queue *Q, ElemType *e);
//读队头元素
bool GetHead(Queue Q, ElemType *e);

CycleQueue.c:

#include "CycleQueue.h"

//初始化队列
void InitQueue(Queue *Q) {
	Q->front = 0;
	Q->rear = 0;
}

//判断队列是否为空
bool Empty(Queue Q) {
	if (Q.front == Q.rear)
		return true;
	else
		return false;
}

//判断队列是否为满
bool Full(Queue Q) {
	if ((Q.rear+1)%MAX == Q.front)
		return true;
	else
		return false;
}

//入队
bool EnQueue(Queue *Q, ElemType e) {
	if (Full(*Q))
		return false;
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAX;
	return true;
}

//出队
bool DeQueue(Queue *Q, ElemType *e) {
	if (Empty(*Q))
		return false;
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAX;
	return true;
}

//读队头元素
bool GetHead(Queue Q, ElemType *e) {
	if (Empty(Q))
		return false;
	*e = Q.data[Q.front];
	return true;
}

//求队列长度
int Length(Queue Q) {
	return (Q.rear + MAX - Q.front) % MAX;
}

main.c:

#include "CycleQueue.h"

int main()
{
	int i = 0;
	Queue Q;
	InitQueue(&Q);
	EnQueue(&Q, 1);
	EnQueue(&Q, 2);
	EnQueue(&Q, 3);
	EnQueue(&Q, 4);
	EnQueue(&Q, 5);//失败！注意在循环队列中，MAX=5的情况下只能有四个位置，剩下那个位置要用来做判断栈满的条件
	printf("队列长:%d\n", Length(Q));

	ElemType e;
	DeQueue(&Q, &e);
	DeQueue(&Q, &e);
	DeQueue(&Q, &e);
	DeQueue(&Q, &e);
	printf("队列长:%d\n", Length(Q));

	EnQueue(&Q, 10);
	EnQueue(&Q, 20);
	EnQueue(&Q, 30);
	printf("队列长:%d\n", Length(Q));
	for (i = 0; i < MAX; i++)
		printf("%d\n", Q.data[i]);
	return 0;
}

三.链队列

LinkQueue.h:

#pragma once
#include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
#define MAX 5
typedef int bool;
typedef int ElemType;
typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node;
typedef struct {
	Node *front;
	Node *rear;
}LinkQueue;
/*
注意到这里链表队列相比 循环队列，顺序队列 有较大的不同, LinkQueue中的front, 和 rear 可以近似看做 head 和 tail,
在操作过程中我们明显感觉到有一个头结点的话更便于操作的进行
*/



//初始化队列
void InitQueue(LinkQueue *Q);
//判断队列是否为空
bool Empty(LinkQueue Q);
//入队(和尾插法基本一样)
void EnQueue(LinkQueue *Q, ElemType e);
//出队
bool DeQueue(LinkQueue *Q, ElemType *e);
//遍历队列
void Traverse(LinkQueue Q);

LinkQueue.c:

#include "LinkQueue.h"

//初始化队列
void InitQueue(LinkQueue *Q) {
	Q->front = (Node*)malloc(sizeof(Node));
	Q->front->data = -1;
	Q->front->next = NULL;
	Q->rear = Q->front;
}

//判断队列是否为空
bool Empty(LinkQueue Q) {
	if (Q.front == Q.rear)
		return true;
	else
		return false;
}

//入队(和尾插法基本一样)
void EnQueue(LinkQueue *Q, ElemType e) {
	Node* pNew = (Node*)malloc(sizeof(Node));
	pNew->data = e;
	pNew->next = NULL;

	pNew->next = Q->rear->next;
	Q->rear->next = pNew;
	Q->rear = pNew;
}

//出队
bool DeQueue(LinkQueue *Q, ElemType *e) {
	if (Empty(*Q))
		return false;
	Node *temp = Q->front->next;
	Q->front->next = Q->front->next->next;
	free(temp);
	return true;
}

//遍历队列
void Traverse(LinkQueue Q) {
	Node *p = Q.front->next;
	while (p) {
		printf("%d->", p->data);
		p = p->next;
	}
	printf("NULL\n");
}

main.c:

#include "LinkQueue.h"

int main()
{
	LinkQueue Q;
	ElemType e;
	InitQueue(&Q);
	EnQueue(&Q, 1);
	EnQueue(&Q, 2);
	EnQueue(&Q, 3);
	EnQueue(&Q, 4);
	Traverse(Q);

	DeQueue(&Q, &e);
	DeQueue(&Q, &e);
	Traverse(Q);

	return 0;
}