C语言--队列（FIFO）_c语言fifo

1、队列的定义

队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入，而在另一端删除元素。这和我们日常生活中排队是一样的，最早进入队列的元素最早离开。

在队列中，允许插入的一端叫做队尾（rear），允许删除的一端则称为队头（front）。

2、队列的基本操作

3、队列的分类

队列包含两种形式：链队列和顺序队列。

3.1、链队列

用链表表示的队列简称为链队列。一个链队列包含两个分别指向队头和队尾的指针（分别成为头指针和尾指针）。

3.1.1  单链队列的定义：

//队列的链式存储结构
typedef struct QNode{
	QElemType data;
	struct QNode *next;
}Qnode,*Queneptr;	
 
typedef struct{
	Queneptr front;//队头指针
	Queneptr rear;//队尾指针
}LinkQuene;	

3.1.2  基本操作

约定：
        队空：s.front=s.rear（有头结点）
        s.front=NULL（无头结点）
        链队无队满的情况（假定内存足够大）

（1）构造一个空队列

Status  init_quene(LinkQuene &s)
{
    s.front=(Queneptr *)malloc(sizeof(Qnode));
    if(!s.front)
        exit(OVERFLOW);
    s.rear=s.front;
    s.front->next=NULL;
 
    return  OK;
}

（2）销毁队列

Status destory_quene(LinkQuene &s,QElemType &e)
{
    while(s.front)
    {
        s.rear = s.front->next;
        free(s.front);
        s.front = s.rear;
    }
    
    retrun  OK;
}

（3）入队

//插入元素e为S的新的队尾元素
Status  en_quene(LinkQuene &s,QElemType e)
{
    Queneptr p=(Queneptr *)malloc(sizeof(Qnode));
    if(!p)
        exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    s.rear->next=p;
    s.rear=p;
 
    return  OK；
}

（4）出队

Status  de_quene(LinkQuene &s,QElemType &e)
{
    if(s.rear == s.front)
    {
        retuen ERROR;
    }
    Queneptr p=s.front->next;
    e=p->data;
    s.front->next=p->next;
    if(s.rear==p)
        s.rear=s.front;
    free(p);
 
    return  OK;
}

3.2、顺序队列

      在队列的顺序存储结构中，除了用一组地址连续的存储单元依次存放从队列头到队列尾的元素之外，尚需附设两个指针 front和 rear 分别指示队列头元素及队列尾元素的位置。

3.2.1  顺序队列的定义

#define  MAXQSIZE    100    //最大队列长度
typedef struct
{
   QelemType  *base;        //初始化的动态分配存储空间
   int front;               //头指针，若队列不空，指向队列头元素
   int rear;                //尾指针，若队列不空，指向队列尾元素的下一个位置
   
}squene;

约定：

       空队列 ：Q.front=Q.rear
       队满 ：Q.front=(Q.rear+1)%MAXSIZE
      入队： Q.rear++
      出队： Q.front++
      非空队列：front始终指向队头元素，rear始终指向队尾元素的下一位置
      每插入一个元素，rear=（rear+1）%（MAXSIZE）
      每删除一个元素，front=（front+1）%（MAXSIZE）

3.2.2  顺序队列的基本操作

（1）构造一个空队列

Status  init_quene(squene &s)
{
    s.base=(QelemType *)malloc(sizeof(QelemType));
    if(!s.base)
        exit(OVERFLOW);  //存储分配失败
    s.front = s.rear =0;
	
    return  OK;
}

（2）求队列的元素个数，即队列的长度

int queue_length(squene s)
{
    //return (s.rear-s.front+1) % MAXSIZE;
    return (s.rear-s.front+MAXSIZE) % MAXSIZE;
}	

（3）入队

//插入元素e 为队列 s 的新的队尾元素
Status en_quene(squene &s,QelemType e)
{
    if(((s.rear+1) % MAXSIZE) == s.front)
    {
        return  ERROR;
    }
    s.base[s.rear] = e;
    s.rear = (s.rear+1) % MAXSIZE;
 
    return  OK;
}	

（4）出队
 

Status de_quene(squene &s,QelemType e)
{
    //若队列不空，则删除 s 的的队头元素，用 e 返回其值，并返回 OK 
    if(s.rear==s.front)
    {
        return  ERROR;
    }
    e = s.base[s.front];
    s.front = (s.front+1) % MAXSIZE;
}

4、其他总结不错的博客

《C语言实现队列的定义及其基本操作》

《队列基本操作》

《c语言之队列结构》