链式队列的初始化到销毁

头文件：

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

#define SUCCESS   100
#define FAILURE   101

typedef int DataType;

struct node
{
	DataType data;
	struct node *next;
};
typedef struct node Node;

struct queue
{
	Node *front;
	Node *rear;
};
typedef struct queue Q;

int InitQueue(Q **q);
int EnterQueue(Q *q, DataType e);
int LengthQueue(Q *q);
int GetFront(Q *q);
int EmptyQueue(Q *q);
int TraverseQueue(Q *q, void (*p)(DataType));
DataType DeleteQueue(Q *q);
int ClearQueue(Q *q);
int DestroyQueue(Q **q);

#endif

子函数：

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

int InitQueue(Q **q)
{
	(*q) = (Q *)malloc(sizeof(Q));
	if (NULL == (*q))
	{
		return FAILURE;
	}

	Node *p = (Node *)malloc(sizeof(Node));
	if (NULL == p)
	{
		return FAILURE;
	}

	p->next = NULL;
	(*q)->front = (*q)->rear = p;

	return SUCCESS;
}

int EnterQueue(Q *q, DataType e)
{
	if (NULL == q)
	{
		return FAILURE;
	}

	Node *p = (Node *)malloc(sizeof(Node));
	if (NULL == p)
	{
		return FAILURE;
	}

	p->data = e;
	p->next = NULL;
	q->rear->next = p;
	q->rear = p;

	return SUCCESS;
}

int LengthQueue(Q *q)
{
	int count = 0;
	Node *p = q->front;

    if(NULL == q)
    {
   		return FAILURE;
	}
	while(p != q->rear)
	{
		p = p->next;
		count++;
	}
	return count;
}

int EmptyQueue(Q *q)
{
    if(q==NULL)
	{
	   return FAILURE;
	}

	return (q->front==q->rear)?  SUCCESS : FAILURE;
}

int GetFront(Q *q)
{
	if(NULL == q || q->front == q->rear)
	{
		return FAILURE;
	}

	return(q->front->next->data);
}

int TraverseQueue(Q *q, void (*p)(DataType))
{
	if(NULL==q)
	{
		return FAILURE;
	}

	Node *n = q->front->next;

	while(n)
	{
		p(n->data);
		n = n->next;
	}

	return SUCCESS;
}

DataType DeleteQueue(Q *q)
{
	DataType e;
	Node *p = q->front->next;

	if (NULL == q || q->rear == q->front)
	{
		return FAILURE;
	}

	e = p->data;
	q->front->next = p->next;
	if (NULL == p->next)
	{
		q->rear = q->front;
	}
	free(p);

	return e;
}

int ClearQueue(Q *q)
{
	if (NULL == q)
	{
		return FAILURE;
	}

	Node *p = q->front->next;

	while (p)
	{
		q->front->next = p->next;
		free(p);
		p = q->front->next;
	}

	q->rear = q->front;

	return SUCCESS;
}

int DestroyQueue(Q **q)
{
	if (NULL == q)
	{
		return FAILURE;
	}

	free((*q)->front);
	free(*q);
	*q = NULL;


	return SUCCESS;
}

主函数：

#include <stdio.h>
#include "LinkQueue.h"

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

int main()
{
	int ret, i;
	Q *queue;

	ret = InitQueue(&queue);
	if (FAILURE == ret)
	{
		printf("Init Failure!\n");
	}
	else
	{
		printf("Init Success!\n");
	}

	for (i = 0; i < 5; i++)
	{
		ret = EnterQueue(queue, i + 1);
		if (FAILURE == ret)
		{
			printf("Enter Failure!\n");
		}
		else
		{
			printf("Enter %d Success!\n", i + 1);
		}
	}

	ret = LengthQueue(queue);
	if (FAILURE == ret)
	{
		printf("Get Length Failure!\n");
	}
	else
	{
		printf("Length is %d\n", ret);
	}

	ret = EmptyQueue(queue);
	if (FAILURE == ret)
	{
		printf("Queue is not Empty!\n");
	}
	else
	{
		printf("Queue is Empty!\n");
	}

	ret = GetFront(queue);
	if (FAILURE == ret)
	{
		printf("Get Front Failure!\n");
	}
	else
	{
		printf("Front is %d!\n", ret);
	}

	ret = TraverseQueue(queue, visit);
	if (FAILURE == ret)
	{
		printf("Traverse Failure!\n");
	}
	else
	{
		printf("Traverse Success!\n");
	}

	for (i = 0; i < 2; i++)
	{
		ret = DeleteQueue(queue);
		if (FAILURE == ret)
		{
			printf("Delete Queue Failure!\n");
		}
		else
		{
			printf("Delete %d Success!\n", ret);
		}
	}

	ret = ClearQueue(queue);
	if (FAILURE == ret)
	{
		printf("Clear Failure!\n");
	}
	else
	{
		printf("Clear Success!\n");
	}

	ret = TraverseQueue(queue, visit);
	if (FAILURE == ret)
	{
		printf("Traverse Failure!\n");
	}
	else
	{
		printf("Traverse Success!\n");
	}

	ret = DestroyQueue(&queue);
	if (FAILURE == ret)
	{
		printf("Destroy Failure!\n");
	}
	else
	{
		printf("Destroy Success!\n");
	}

	ret = TraverseQueue(queue, visit);
	if (FAILURE == ret)
	{
		printf("Traverse Failure!\n");
	}
	else
	{
		printf("Traverse Success!\n");
	}

	return 0;
}