C源码@数据结构与算法->队列（queue）

最新推荐文章于 2021-11-08 23:26:56 发布

原创最新推荐文章于 2021-11-08 23:26:56 发布 · 468 阅读

0 ·

CC 4.0 BY-SA版权

笔记_数据结构与算法分析(C语言描述) 专栏收录该内容

15 篇文章

订阅专栏

本文详细探讨了如何使用C语言实现数据结构中的队列。通过讲解队列的基本概念、操作以及实例代码，深入理解其工作原理。内容包括静态队列和动态链式队列的创建、入队、出队等操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
 * testqueue.cpp
 */
#include 
#include "queue.h"

int main()
{
	Queue Q = NULL;
	int i;

	Q = CreateQueue(12);

	for (i = 0; i < 10; ++i)
	{
		Enqueue(i, Q);
	}

	while (!IsEmpty(Q))
	{
		printf("%d\n", Front(Q));
		Dequeue(Q);
	}

	for (i = 0; i < 10; ++i)
	{
		Enqueue(i, Q);
	}

	while (!IsEmpty(Q))
	{
		printf("%d\n", Front(Q));
		Dequeue(Q);
	}

	DisposeQueue(Q);

	return 0;
}

/*
 * queue.h
 */
#ifndef _QUEUE_H
#define _QUEUE_H

#ifndef NULL
#define NULL (0)
#endif

typedef int ElementType;

struct QueueRecord;
typedef struct QueueRecord *Queue;

#ifdef __cplusplus
extern "C" {
#endif

Queue CreateQueue(int MaxElements);
void MakeEmpty(Queue Q);
void DisposeQueue(Queue Q);
int IsEmpty(Queue Q);
int IsFull(Queue Q);
void Enqueue(ElementType X, Queue Q);
void Dequeue(Queue Q);
ElementType Front(Queue Q);
ElementType FrontAndDequeue(Queue Q);

#ifdef __cplusplus
}
#endif

#endif

/*
 * queue.cpp
 */
#include 
#include "fatal.h"
#include "queue.h"

#define MiniQueueSize (10)

struct QueueRecord
{
	int Capacity;
	int Front;
	int Rear;
	int Size;
	ElementType *Array;
};

Queue CreateQueue(int MaxElements)
{
	Queue Q;

	if (MaxElements < MiniQueueSize)
	{
		FatalError("Queue size is too small!");
	}

	Q = (Queue)malloc(sizeof(struct QueueRecord));
	if (Q == NULL)
	{
		FatalError("Out of memory!");
	}

	Q->Array = (ElementType *)malloc(sizeof(ElementType) * MaxElements);
	if (Q->Array == NULL)
	{
		FatalError("Out of memory!");
	}

	Q->Capacity = MaxElements;

	MakeEmpty(Q);

	return Q;
}

void MakeEmpty(Queue Q)
{
	Q->Size = 0;
	Q->Front = 1;
	Q->Rear = 0;
}

void DisposeQueue(Queue Q)
{
	if (Q != NULL)
	{
		free(Q->Array);
		free(Q);
	}
}

int IsEmpty(Queue Q)
{
	return Q->Size == 0;
}

int IsFull(Queue Q)
{
	return Q->Size == Q->Capacity;
}

static int Succ(int Index, Queue Q)
{
	if (++Index == Q->Capacity)
	{
		Index = 0;
	}
	return Index;
}

void Enqueue(ElementType X, Queue Q)
{
	if (IsFull(Q))
	{
		FatalError("Qull queue!");
	}
	else
	{
		++Q->Size;
//		Q->Rear = Succ(Q->Rear, Q);
		Q->Rear = (++Q->Rear == Q->Capacity) ? 0 : Q->Rear;
		Q->Array[Q->Rear] = X;
	}
}

void Dequeue(Queue Q)
{
	if (IsEmpty(Q))
	{
		FatalError("Empty queue!");
	}
	else
	{
		--Q->Size;
//		Q->Front = Succ(Q->Front, Q);
		Q->Front = (++Q->Front == Q->Capacity) ? 0 : Q->Front;
	}
}

ElementType Front(Queue Q)
{
	if (IsEmpty(Q))
	{
		FatalError("Empty queue!");
		return -1;				/* Return value used to avoid warning */
	}
	else
	{
		return Q->Array[Q->Front];
	}
}

ElementType FrontAndDequeue(Queue Q)
{
	ElementType X = -1;

	if (IsEmpty(Q))
	{
		FatalError("Empty queue!");
	}
	else
	{
		--Q->Size;
		X =  Q->Array[Q->Front];
//		Q->Front = Succ(Q->Front, Q);
		Q->Front = (++Q->Front == Q->Capacity) ? 0 : Q->Front;
	}

	return X;
}