双端队列的已满C语言CSDN,C语言实现双端循环队列

DeQueue.h

#pragma once

/*

双端队列(注：不是双向队列)：是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。

*/

#define MAX_SIZE 20

#define ElemType int

#define OVERFLOW -2

#define ERROR -1

typedef struct {

ElemType* base;

int front;

int rear;

int size;

}de_queue;

void InitQueue(de_queue& Q);//初始化队列

void DetroyQueue(de_queue& Q);//销毁队列

void ClearQueue(de_queue& Q);//清空队列

bool EmptyQueue(de_queue Q);//判断队列是否为空 其实这里最好也使用引用传递，值传递会内存拷贝影响性能，具体有待后续研究

bool FullQueue(de_queue Q);//判断队列是否已满

void EnFront(de_queue& Q,ElemType e);//头插

void EnRear(de_queue& Q, ElemType e);//尾插

void DeFront(de_queue& Q, ElemType& e);//头出

void DeRear(de_queue& Q, ElemType& e);//尾出

int LengthQueue(de_queue Q);//获取队列长度

void TraverseQueue(de_queue Q,void(*f)(ElemType e));//遍历队列

DeQueue.cpp

#include #include "DeQueue.h"

void InitQueue(de_queue& Q) {

Q.base = (ElemType*)malloc(MAX_SIZE * sizeof(ElemType));

if (!Q.base) exit(ERROR);

Q.front = Q.rear = 0;

Q.size = MAX_SIZE;

}//初始化队列

void DetroyQueue(de_queue& Q) {

Q.rear = Q.front = 0;

free(Q.base);

Q.size = 0;

}//销毁队列

void ClearQueue(de_queue& Q) {

Q.rear = Q.front = 0;

}

bool EmptyQueue(de_queue Q) {

return Q.rear == Q.front ? true : false;

}//判断队列是否为空 其实这里最好也使用引用传递，值传递会内存拷贝影响性能，具体有待后续研究

bool FullQueue(de_queue Q) {

return (Q.rear + 1)%Q.size == Q.front ? true:false;

}//判断队列是否已满

void EnFront(de_queue& Q, ElemType e) {

if (FullQueue(Q)) exit(OVERFLOW);//判断是否满队

Q.front = (Q.front +Q.size- 1) % Q.size;

*(Q.base+Q.front) = e;

}//头插

void EnRear(de_queue& Q, ElemType e) {

if (FullQueue(Q)) exit(OVERFLOW);

*((Q.base + Q.rear)) = e;

Q.rear = ++Q.rear % Q.size;

}//尾插

void DeFront(de_queue& Q, ElemType& e) {

if (EmptyQueue(Q)) exit(ERROR);

e = *(Q.base+Q.front);

Q.front = (Q.front+1) % Q.size;

}//头出

void DeRear(de_queue& Q, ElemType& e) {

if(EmptyQueue(Q)) exit(ERROR);

Q.rear = (Q.rear +Q.size- 1)%Q.size;

e = *(Q.base + Q.rear);

}//尾出

int LengthQueue(de_queue Q) {

return (Q.rear +Q.size- Q.front) % Q.size;

}//获取队列长度

void TraverseQueue(de_queue Q, void(*f)(ElemType e)) {

int index = Q.front;

while (index!=Q.rear)

{

f(*(Q.base+index));

index = ++index % Q.size;

}

}//遍历队列

main.cpp(用于测试)

#include #include#include #include "DeQueue.h"

void printQ(ElemType e) {

printf("%c ",e);

}

int main() {

char opt[20];

de_queue queue;

InitQueue(queue);

ElemType e;

while (true)

{

gets_s(opt, 20);

if (strcmp(opt, "enf")==0) {

printf("wait for input:");

EnFront(queue, getchar());

getchar();

}

else if (strcmp(opt, "enr") == 0) {

printf("wait for input:");

EnRear(queue, getchar());

getchar();

}

else if (strcmp(opt, "def") == 0) {

DeFront(queue, e);

printf("out from front:%c\n",e);

}

else if (strcmp(opt, "der") == 0) {

DeRear(queue, e);

printf("out from rear:%c\n", e);

}

else if (strcmp(opt, "exit") == 0) {

break;

}

else {

printf("unknow operate\n");

continue;

}

TraverseQueue(queue,printQ);

printf("\n");

}

return 0;

}