队列 C语言（转）

概念

队列的操作

队列是受限制的线性表，只允许在队尾（tail）插入、对头（head）删除。

队列的操作方式与堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。

队列的属性

以队列q为例。

q.head指向队头元素；
q.tail指向下一个新元素将要插入的位置。

在队列中，位置1紧邻在n的后面形成一个环序。

队列的状态

当q.head = q.tail时，队列为空，
初始时有q.head = q.tail = 1 ；
当q.head = q.tail + 1时，队列是满的 。

数组实现

利用数组q.key[n]实现一个最多容纳n-1个元素的队列。

# include <stdio.h>
# define M 100
typedef struct queue {
 int head;
 int tail;
 int key[M];
 int length;
} queue;
queue q;
void enqueue(int x);
int dequeue(void);
int main(void)
{
 q.head = q.tail = 1;
 q.length = 98;
 enqueue(1);
 enqueue(3);
 enqueue(5);
 enqueue(7);
 printf("%d\n", dequeue());
 printf("%d\n", dequeue());
 printf("%d\n", dequeue());
 printf("\t%d\n", q.head);
 printf("%d\n", dequeue());
}
void enqueue(int x)
{
 q.key[q.tail] = x;
 if(q.tail == q.length) {
  q.tail = 1;
 } else {
  q.tail++;
 }
}
int dequeue(void)
{
 int x;
 
 x = q.key[q.head];
 if(q.head == q.length) {
  q.head = 1;
 } else {
  q.head++;
 }
 return x;
}

全局变量实现

全局变量也挺方便的，只是注意不要和局部变量重名而被取代了。

# include <stdio.h>
# define M 100
typedef struct queue {
 int head;
 int tail;
 int key[M];
 int length;
} queue;

void enqueue(queue * qp, int x);
int dequeue(queue * qp);
int main(void)
{
 queue q;
 q.head = q.tail = 1;
 q.length = 98;
 enqueue(&q, 1);
 enqueue(&q, 3);
 enqueue(&q, 5);
 enqueue(&q, 7);
 printf("%d\n", dequeue(&q));
 printf("%d\n", dequeue(&q));
 printf("%d\n", dequeue(&q));
 printf("%d\n", dequeue(&q));
}
void enqueue(queue * pq, int x)
{
 pq -> key[pq -> tail] = x;
 if(pq -> tail == pq -> length) {
  pq -> tail = 1;
 } else {
  pq -> tail++;
 }
}
int dequeue(queue * pq)
{
 int x;
 
 x = pq -> key[pq -> head];
 if(pq -> head == pq -> length) {
  pq -> head = 1;
 } else {
  pq -> head++;
 }
 return x;
}

整体实现

#include<malloc.h>
#include<stdio.h>


#ifndef Queue_H
#define Queue_H


typedef int Item;
typedef struct node * PNode;
typedef struct node
{
Item data;
PNode next;
}Node;


typedef struct
{
PNode front;
PNode rear;
int size;
}Queue;


/*构造一个空队列*/
Queue *InitQueue();


/*销毁一个队列*/
void DestroyQueue(Queue *pqueue);


/*清空一个队列*/
void ClearQueue(Queue *pqueue);


/*判断队列是否为空*/
int IsEmpty(Queue *pqueue);


/*返回队列大小*/
int GetSize(Queue *pqueue);


/*返回队头元素*/
PNode GetFront(Queue *pqueue,Item *pitem);


/*返回队尾元素*/
PNode GetRear(Queue *pqueue,Item *pitem);


/*将新元素入队*/
PNode EnQueue(Queue *pqueue,Item item);


/*队头元素出队*/
PNode DeQueue(Queue *pqueue,Item *pitem);


/*遍历队列并对各数据项调用visit函数*/
void QueueTraverse(Queue *pqueue,void (*visit)());


#endif






/*构造一个空队列*/
Queue *InitQueue()
{
Queue *pqueue = (Queue *)malloc(sizeof(Queue));
if(pqueue!=NULL)
{
pqueue->front = NULL;
pqueue->rear = NULL;
pqueue->size = 0;
}
return pqueue;
}


/*销毁一个队列*/
void DestroyQueue(Queue *pqueue)
{
if(IsEmpty(pqueue)!=1)
ClearQueue(pqueue);
free(pqueue);
}


/*清空一个队列*/
void ClearQueue(Queue *pqueue)
{
while(IsEmpty(pqueue)!=1)
{
DeQueue(pqueue,NULL);
}


}


/*判断队列是否为空*/
int IsEmpty(Queue *pqueue)
{
if(pqueue->front==NULL&&pqueue->rear==NULL&&pqueue->size==0)
return 1;
else
return 0;
}


/*返回队列大小*/
int GetSize(Queue *pqueue)
{
return pqueue->size;
}


/*返回队头元素*/
PNode GetFront(Queue *pqueue,Item *pitem)
{
if(IsEmpty(pqueue)!=1&&pitem!=NULL)
{
*pitem = pqueue->front->data;
}
return pqueue->front;
}


/*返回队尾元素*/


PNode GetRear(Queue *pqueue,Item *pitem)
{
if(IsEmpty(pqueue)!=1&&pitem!=NULL)
{
*pitem = pqueue->rear->data;
}
return pqueue->rear;
}


/*将新元素入队*/
PNode EnQueue(Queue *pqueue,Item item)
{
PNode pnode = (PNode)malloc(sizeof(Node));
if(pnode != NULL)
{
pnode->data = item;
pnode->next = NULL;

if(IsEmpty(pqueue))
{
pqueue->front = pnode;
}
else
{
pqueue->rear->next = pnode;
}
pqueue->rear = pnode;
pqueue->size++;
}
return pnode;
}


/*队头元素出队*/
PNode DeQueue(Queue *pqueue,Item *pitem)
{
PNode pnode = pqueue->front;
if(IsEmpty(pqueue)!=1&&pnode!=NULL)
{
if(pitem!=NULL)
*pitem = pnode->data;
pqueue->size--;
pqueue->front = pnode->next;
free(pnode);
if(pqueue->size==0)
pqueue->rear = NULL;
}
return pqueue->front;
}


/*遍历队列并对各数据项调用visit函数*/
void QueueTraverse(Queue *pqueue,void (*visit)())
{
PNode pnode = pqueue->front;
int i = pqueue->size;
while(i--)
{
// visit(pnode->data);
pnode = pnode->next;
}

}




void print(Item i)
{
printf("该节点元素为%d\n",i);
}




void use_fun11(void)
{
Queue *pq = InitQueue();
int i,item;
printf("0-9依次入队并输出如下：\n");
for(i=0;i<10;i++)
{
EnQueue(pq,i);
GetRear(pq,&item);
printf("%d ",item);
}


printf("\n从队头到队尾遍历并对每个元素执行print函数：\n");
QueueTraverse(pq,print);


printf("队列中元素依次出队列并输出如下：\n");
for(i=0;i<10;i++)
{
DeQueue(pq,&item);
printf("%d ",item);
}
ClearQueue(pq);
if(IsEmpty(pq))
printf("\n将队列置空成功\n");
DestroyQueue(pq);
printf("队列已被销毁\n");
}