c语言先进先出数组实现,数据结构——C语言实现队列

C语言实现队列

1.队列的结构及相关概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)的特性。

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

2.队列的实现：

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。下面，我们描述如何使用链表实现队列。

QueueNode.h文件：

typedef int DataType;

typedef struct QueueNode

{

struct QueueNode* _next;

DataType _data;

}QueueNode;

typedef struct Queue

{

QueueNode* _front;//队头

QueueNode* _rear;//队尾

}Queue;

void QueueInit(Queue* p);//初始化队列

void QueueDestory(Queue* p);//销毁队列

void QueuePush(Queue* p,DataType x);//入队

void QueuePop(Queue* p);//出队

DataType QueueFront(Queue* p);//获取队首元素

DataType QueueBack(Queue* p);//获取队尾元素

int QueueEmpty(Queue* p);//判断队列是否为空

int QueueSize(Queue* p);//队列的大小

void Queueprint(Queue* p);//打印队列

void TestQueue();//测试

QueueNode.c文件：

//对队列进行初始化

void QueueInit(Queue* p)

{

assert(p);

p->_front = p->_rear = NULL;

}

//销毁队列

void QueueDestory(Queue* p)

{

assert(p);

QueueNode* cur = p->_front;

while (cur)

{

p->_front = cur->_next;

free(cur);

cur = p->_front;

}

//将队尾置空

p->_rear = NULL;

}

//入队：队尾插入元素

void QueuePush(Queue* p, DataType x)

{

assert(p);

QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));

newNode->_data = x;

newNode->_next = NULL;

//判断是否为第一个插入的元素

if (p->_front == NULL)

{

p->_front = p->_rear = newNode;

}

else

{

p->_rear->_next = newNode;

p->_rear = p->_rear->_next;

}

}

//出队：队首删除元素

void QueuePop(Queue* p)

{

assert(p);

if (p->_front)

{

QueueNode* next = p->_front->_next;

//删除，出队

free(p->_front);

p->_front = next;

//如果删除的为最后一个元素

if (p->_front == NULL)

{

p->_rear = NULL;

}

}

}

//获取队首元素

DataType QueueFront(Queue* p)

{

assert(p);

return p->_front->_data;

}

DataType QueueBack(Queue* p)

{

assert(p);

return p->_rear->_data;

}

//判断队列是否为空

int QueueEmpty(Queue* p)

{

assert(p);

if (p->_front == NULL)

{

return 1;

}

else

{

return 0;

}

}

//队列的大小

int QueueSize(Queue* p)

{

assert(p);

QueueNode* cur = p->_front;

DataType n = 0;

while (cur)

{

++n;

cur = cur->_next;

}

}

//打印队列

void Queueprint(Queue* p)

{

assert(p);

QueueNode* cur = p->_front;

while (cur)

{

printf("%d ", cur->_data);

cur = cur->_next;

}

printf("\n");

}

//测试

void TestQueue()

{

Queue p;

QueueInit(&p);

QueuePush(&p, 1);

QueuePush(&p, 2);

QueuePush(&p, 3);

QueuePush(&p, 4);

QueuePop(&p);

QueuePop(&p);

Queueprint(&p);

}

main.c文件：

int main()

{

TestQueue();

return 0;

}

队列中需特别理解队列的特性——先进先出规则。

在实际使用中还有一种特殊的队列——循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

循环队列的实现(leetcode上的原题)：

//函数接口说明：

//MyCircularQueue(k) : 构造器，设置队列长度为 k 。

//Front : 从队首获取元素。如果队列为空，返回 - 1 。

//Rear : 获取队尾元素。如果队列为空，返回 - 1 。

//enQueue(value) : 向循环队列插入一个元素。如果成功插入则返回真。

//deQueue() : 从循环队列中删除一个元素。如果成功删除则返回真。

//isEmpty() : 检查循环队列是否为空。

//isFull() : 检查循环队列是否已满。

//free():释放空间

typedef struct

{

int* _a;

int _front;//队首

int _rear;//队尾

int _k;

} MyCircularQueue;

/** Checks whether the circular queue is empty or not. */

//判断为空的条件即是队尾等于队首

bool myCircularQueueIsEmpty(MyCircularQueue* obj)

{

return obj->_front == obj->_rear;

}

/** Checks whether the circular queue is full or not. */

//判断是否已满的条件是(队尾大小+1)%(容量大小+1)== 队首大小。

bool myCircularQueueIsFull(MyCircularQueue* obj) {

return ((obj->_rear + 1) % (obj->_k) == (obj->_front));

}

/** Initialize your data structure here. Set the size of the queue to be k. */

MyCircularQueue* myCircularQueueCreate(int k)

{

MyCircularQueue* Queue = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

Queue->_a = (int*)malooc(sizeof(int)*(k + 1));

Queue->_front = 0;

Queue->_rear = 0;

Queue->_k = k;

}

/** Insert an element into the circular queue. Return true if the operation is successful. */

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)

{

assert(obj);

if (myCircularQueueIsFull(obj))

{

return false;

}

obj->_a[obj->_rear] = value;

obj->_rear++;

if (obj->_rear == obj->_k + 1)

{

obj->_rear = 0;

}

return true;

}

** Delete an element from the circular queue. Return true if the operation is successful. */

bool myCircularQueueDeQueue(MyCircularQueue* obj)

{

assert(obj);

if (myCircularQueueIsEmpty(obj))

{

return false;

}

obj->_front++;

if (obj->_front == obj->_k + 1)

{

obj->_front = 0;

}

return true;

}

/** Get the front item from the queue. */

int myCircularQueueFront(MyCircularQueue* obj)

{

assert(obj);

if (myCircularQueueIsEmpty(obj))

{

return -1;

}

return obj->_a[obj->_front];

}

/** Get the last item from the queue. */

int myCircularQueueRear(MyCircularQueue* obj)

{

assert(obj);

if (myCircularQueueIsEmpty(obj))

{

return -1;

}

if (obj->_rear == 0)

{

return obj->_a[obj->_k];

}

return obj->_a[obj->_rear - 1];

}

void myCircularQueueFree(MyCircularQueue* obj)

{

free(obj->_a);

free(obj);

}

需注意：循环队列是逻辑上循环，物理上不循环的。