链式队列

用链表实现链式队列

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define ERROR 0
#define OK 1

typedef int elemType;

typedef struct qNode
{
	elemType data;
	struct qNode * qNext;
}* nodePtr;


typedef struct linkQueue
{
	nodePtr front;
	nodePtr rear;
}* queuePtr;

void initQueue(queuePtr qPtr)
{
	qPtr->rear = (nodePtr)malloc(sizeof(qNode));
	if(!(qPtr->rear))
	{
		exit(OVERFLOW);
	}
	else
	{
		qPtr->front = qPtr->rear;
		qPtr->front->qNext = NULL;
	}
}

void destoryQueue(queuePtr qPtr)
{
	while(qPtr->front != NULL)
	{
		qPtr->rear = qPtr->front->qNext;
		free(qPtr->front);
		qPtr->front = qPtr->rear;
	}
}

void clearQueue(queuePtr qPtr)
{
	destoryQueue(qPtr);
	initQueue(qPtr);
}

bool queueEmpty(queuePtr qPtr)
{
	if(qPtr->front->qNext == NULL)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

int queueLength(queuePtr qPtr)
{
	int i = 0;
	nodePtr p = qPtr->front;
	while(qPtr->rear != p)
	{
		i++;
		p = p->qNext;
	}
	return i;
}

bool getHead(queuePtr qPtr, elemType * val)
{
	nodePtr p;
	if(qPtr->front == qPtr->rear)
	{
		return ERROR;
	}

	p = qPtr->front->qNext;
	*val = p->data;
	return OK;
}

void endInsertQueue(queuePtr qPtr, elemType val)
{
	nodePtr p = (nodePtr)malloc(sizeof(qNode));
	if(!p)
	{
		exit(OVERFLOW);
	}
	p->data = val;
	p->qNext = NULL;
	qPtr->rear->qNext = p;
	qPtr->rear = p;
}

bool delfrontQueue(queuePtr qPtr, elemType *val)
{
	nodePtr p = qPtr->front->qNext;
	if(queueEmpty(qPtr))
	{
		return ERROR;
	}
	*val = p->data;
	qPtr->front->qNext = p->qNext;
	if(qPtr->rear == p)
	{
		qPtr->rear = qPtr->front;
	}
	free(p);
	p = NULL;
	return OK;
}

void queueTraverse(queuePtr qPtr, void(* visit)(elemType))
{
	nodePtr p = qPtr->front->qNext;
	while(p)
	{
		visit(p->data);
		p = p->qNext;
	}

	printf("\n");
}

void visit(elemType e)
{
	printf("%d, ", e);
}



int main(int argc, char const *argv[])
{
	struct linkQueue lq;
	queuePtr qPtr = &lq;
	elemType e;

	initQueue(qPtr);
	
	for(int i=1; i<=10; i++)
	{
		endInsertQueue(qPtr, i*2);
	}
	printf("Is queue is empty?:%d\n", queueEmpty(qPtr));
	printf("queue length is:%d\n", queueLength(qPtr));
	queueTraverse(qPtr, visit);

	printf("Success!!!\n");

	endInsertQueue(qPtr, 10000);
	queueTraverse(qPtr, visit);

	delfrontQueue(qPtr, &e);
	printf("delete:%d\n", e);
	queueTraverse(qPtr, visit);


	return 0;
}