队列

队列类型的定义

 队列(queue): 限定在只能在表的两端分别进行插入或删除操作的线性表

 数据只能从一端(队尾rear)插入,从另一端(对头front)删除.

 空队: 队列中没有包含元素 front == rear;

入队(Enqueue): 向一个队列插入一个元素，插入的元素成为新的队尾元素

出队(Dequeue):从队列删除一个元素，只能删除当前的对头元素

First  In First Out  , 先进先出线性表

循环队列的表示和实现

  rear指向当前队尾元素的下一个位置，也就是插入新元素的位置;

 front指向当前对头元素

队尾移动方式

rear=(rear+1)%MAXSIZE;

对头移动方式

front=(front+1)%front

对空时: front ==rear;

对满时:  (rear+1)%MAXSIZE ==front;

#define MAXSIZE 100
typedef struct
{
	int * base; //指向循环队列的存储空间
	int front;
	int rear;
}SqQueue;

int InitQueue(SqQueue *Q)
{
	Q->base = (int *)malloc(MAXSIZE*sizeof(int));
	if (!Q->base) return ERROR;
	Q->front = Q->rear = 0;
	return OK;
}

int EnQueue(SqQueue * Q, int  e)
{
	if ((Q->rear + 1)%MAXSIZE ==Q->front)
		return ERROR;
	Q->base[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXSIZE;
	return OK;
}
int DeQueue(SqQueue *Q, int *e)
{
	if (Q->front == Q->rear)
		return ERROR;
	*e = Q->base[Q->front];
	Q->front = (Q->front+1) % MAXSIZE;
}
int QueueEmpty(SqQueue *Q)
{
	if (Q->front == Q->rear)  return OK;
	else
		return ERROR;
}

 链队的表示和实现

  采用链式存储结构表示队列 ，称为链队

在链队结构中增加一个头节点，并使队头指针front指向头节点.

typedef struct LinkNode
{
	int data;
	struct LinkNode *next;
}LinkNode;

typedef struct LinkQueue
{
	LinkNode * front, *rear;

}LinkQueue;

int  InitQueue_L(LinkQueue *Q)
{
	LinkNode *p;
	p = (LinkNode *)malloc(sizeof(LinkNode));
	if (!p) return ERROR;
	p->next = NULL;
	Q->front = Q->rear = p;
}
int EnQueue_L(LinkQueue *Q, int e)
{
	LinkNode  *node;
	node = (LinkNode *)malloc(sizeof(LinkNode));
	if (!node) return ERROR;
	node->data = e;
	node->next = NULL;
	Q->rear->next = node;
	Q->rear = node;
	return OK;
}
int DeQueue_L(LinkQueue *Q , int *e)
{
	LinkNode *p;
	if (Q->rear == Q->front) return ERROR;
	p = Q->front->next;
	*e = p->data;
	if (Q->front->next == Q->rear) {
		Q->front->next = NULL;
		Q->rear = Q->front;	
	}
	else {

		Q->front->next = p->next;
	}
	free(p);
	return OK;

}