数据结构—队列

定义：
　　和栈一样，是一种操作受限的线性表，其限制为只允许在一头插入（入队）在另一头删除（出队）。插入的一端叫队尾，删除的一端叫队首。
特点：
　　先进先出，像是过独木桥，先上去的先下来。
存储结构:
　1、顺序存储：
　　　　以数组来实现，指向队首和队尾的指针则是数组首元素和尾元素的下标。
　　　　队空条件：q->front= =q->rear。
　　　　队满条件：q->rear= =N-1(data数组的最大下标)。
　　　　元素n入队操作：先将rear加1，然后将元素n放在data数组的rear位置。
　　　　出队操作：先将front加1，然后取出data数组中front位置的元素。
　　　　定义如下：

　　　　　　#define N 10
　　　　　　typedef struct lei
　　　　　　{
 　　　　　　　 　int data[N];                //存放队中元素
  　　　　　　　  int front,rear;             //队首和队尾指针
　　　　　　}lei;

注：用普通的数组存储队列元素时，经过出队操作后的空间无法重复利用。所以，为了不必要的空间浪费，一般把数组data定义成环形数组。这样的话队空条件将发生变化，有兴趣的可自行了解。
　2、链式存储：
　　　　以链表来实现数据存储，通常为单链表。
　　　　队空条件：q->rear= =NULL(也可以是q->front= =NULL)。
　　　　队满条件：这个可以不考虑，因为链表的可扩展性。
　　　　元素n进队操作：新建一个结点存放n（由p指向它），将节点p插入做为尾节点。
　　　　出队操作：取首结点的data值，并将其删除。
　　　　定义如下：

　　　　　　typedef struct qnode
　　　　　　{
  　　　　　　　 int data;              //存放元素
   　　　　　　　struct qnode *next;    //下一个结点指针
　　　　　　}DataNode;
　　　　　　typedef struct lei
　　　　　　{
  　　　　　 　 DataNode *front;    　  //指向队首节点
   　　　　　　 DataNode *rear;     　  //指向队尾节点
　　　　　　}lei;

注：队列的数组实现比较麻烦，需要考虑各种边界情况，所以通常使用链表形式来实现队列。为了方便实现，链式队列中的front表示链表的头节点，而front的next才表示队头。
基本操作：

InitQueue(q);   //队列初始化
DestroyQueue(q);//销毁队列
push(q,n);      //入队，在队尾插入元素n
pop(q,n);       //出队，在队首删除元素,并将其值赋给n返回
empty(q);       //判断是否为空

操作函数实现（顺序存储结构）

void InitQueue(lei *&q)         //队列初始化
{
    q=(lei *)malloc(sizeof(lei));
    q->front=q->rear=-1;
}
void DestroyQueue(lei *&q)      //销毁队列
{
    free(q);
}
bool push(lei *&q,int n)        //入队列
{
    if(q->rear==N-1)//溢出
        return false;
    q->rear++;
    q->data[q->rear]=n;
    return true;
}
bool pop(lei *&q,int &n)        //出队列，并返回其值
{
    if(q->front==q->rear)//队列为空
        return false;
    q->front++;
    n=q->data[q->front];
    return true;
}
bool empty(lei *q)              //判断队列是否为空
{
    return(q->front==q->rear);
}

操作函数实现（线性存储）

void InitQueue(lei *&q)          //初始化队列
{
    q=(lei *)malloc(sizeof(lei));
    q->front=q->rear=NULL;
}
void DestroyQueue(lei *&q)       //销毁队列
{
    DataNode *pre=q->front,*p;//pre指向队首结点
    if(pre!=NULL)
    {
        p=pre->next;
        while(p!=NULL)
        {
            free(pre);  
            pre=p;
            p=p->next;  //pre,p同步后移
        }
        free(pre);      //释放最后一个数据结点
    }
    free(q);            //释放链队结点
}
bool empty(lei *q)              //判断是否为空
{
    return (q->rear==NULL)
}
void push(lei *&q,int n)        //入队，在队尾插入新元素
{
    DataNode *p;
    p=(DataNode *)malloc(sizeof(DataNode)); //创建新节点
    p->data=n;
    p->next=NULL;
    if(q->rear==NULL)       //若为空队，则队首元素等于队尾元素
    {
        q->front=q->rear=p;
    }
    else                    //不为空，将新结点连到队尾，并用rear指向它
    {
        q->rear->next=p;
        q->rear=p;
    }
}
bool pop(lei *&q,int &n)         //出队，并返回元素值
{
    DataNode *t;
    if(q->rear==NULL)      //队列为空则返回false
        return false;
    t=q->rear;
    if(q->front==q->rear)  //队列只有一个数据结点时
        q->front=q->rear=NULL;
    else                   //有两个结点以上时
        q->front=q->front->next;
    n=t->data;
    free(t);
    return true;
}

代码示例：
　　以顺序存储为例

int main()
{
    void InitQueue(lei *&q);             
    void DestroyQueue(lei *&q);          
    bool push(lei *&q,int n);            
    bool pop(lei *&q,int &n);            
    bool empty(lei *q);                 
    lei *q;
    int b[10]={1,2,3,4,5,6,7,8,9,10},n=11,i;
    InitQueue(q);
    for(i=0;i<10;i++)
    {
        push(q,b[i]);
    }
    printf("输出队列中全部元素：\n");
    for(i=0;i<10;i++)
    {
         printf("%d ",q->data[i]);
    }
    printf("\n\n");
    printf("入队：%d\n",n);
    push(q,n);
    printf("输出队列中全部元素：\n");
    while(!empty(q))
    {
        pop(q,n);
        printf("%d ",n);
    }
    printf("\n\n");
    printf("判断队列是否为空\n");
    if(empty(q))
    {
         printf("队列为空\n");
    }
    else printf("队列不为空\n");
    DestroyQueue(q);
    return 0;
}

输出如下：