队列顺序循环存储实现

#ifndef _CIRCULAR_SEQUENCE_QUEUE_LIST_H_
#define _CIRCULAR_SEQUENCE_QUEUE_LIST_H_

/************************************************************************/
/*                    队列顺序循环存储实现CirSeqQueueList                  */
/************************************************************************/

typedef struct CirSeqQueueList
{
	int head;
	int tail;
	ElemType* data;
}CirSeqQueueList;

/**初始化操作，建立一个空的队列Q。*/
Status InitQueue(CirSeqQueueList* Q);

/**若队列存在，则销毁它*/
Status DestoryQueue(CirSeqQueueList* Q);

/**将队列清空*/
Status ClearQueue(CirSeqQueueList* Q);

/**若队列为空返回true,否则返回false*/
bool QueueEmpty(CirSeqQueueList Q);

/**若队列不为空，返回队头元素*/
Status GetHead(CirSeqQueueList Q,ElemType *e);

/**如果队列存在，插入新元素e到队列Q中，并成为队尾元素*/
Status EnQueue(CirSeqQueueList* Q,ElemType e);

/**删除队列Q中队头元素，并返回这个位置的元素值e*/
Status DeQueue(CirSeqQueueList* Q,ElemType* e);

/**返回队列Q的元素个数*/
int QueueLength(CirSeqQueueList Q);

/**遍历队列元素*/
Status TraverseQueue(CirSeqQueueList Q);

#endif//_CIRCULAR_SEQUENCE_QUEUE_LIST_H_

#include "stdafx.h"
#include "CirSeqQueueList.h"

/**初始化操作，建立一个空的队列Q。*/
Status InitQueue(CirSeqQueueList* Q)
{
	Q->data = (ElemType*)malloc(sizeof(ElemType)*MaxCapacity);
	Q->head = 0;
	Q->tail = 0;
	return OK;
}

/**若队列存在，则销毁它*/
Status DestoryQueue(CirSeqQueueList* Q)
{
	free(Q->data);
	Q->data = NULL;
	Q->head = 0;
	Q->tail = 0;

	return OK;
}

/**将队列清空*/
Status ClearQueue(CirSeqQueueList* Q)
{
	Q->head = 0;
	Q->tail = 0;
	return OK;
}

/**若队列为空返回true,否则返回false*/
bool QueueEmpty(CirSeqQueueList Q)
{
	return Q.head == Q.tail;
}

/**若队列不为空，返回队头元素*/
Status GetHead(CirSeqQueueList Q,ElemType *e)
{
	if(QueueEmpty(Q))
		return ERROR;

	*e = Q.data[Q.head];
	return OK;
}

/**如果队列存在，插入新元素e到队列Q中，并成为队尾元素*/
Status EnQueue(CirSeqQueueList* Q,ElemType e)
{
	if((Q->tail+1)%MaxCapacity == Q->head)
		return ERROR;

	Q->data[Q->tail] = e;
	Q->tail = (Q->tail+1) % MaxCapacity;//尾指针后移，若到数组最后，则转到数组头部
	return OK;
}

/**删除队列Q中队头元素，并返回这个位置的元素值e*/
Status DeQueue(CirSeqQueueList* Q,ElemType* e)
{
	if(QueueEmpty(*Q))
		return ERROR;

	*e = Q->data[Q->head];
	Q->head = (Q->head + 1) % MaxCapacity;//头指针后移，若到数组最后，则转到数组头部

	return OK;
}

/**返回队列Q的元素个数*/
int QueueLength(CirSeqQueueList Q)
{
	return (Q.tail - Q.head + MaxCapacity) % MaxCapacity;
}

/**遍历队列元素*/
Status TraverseQueue(CirSeqQueueList Q)
{
	int k = 0;
	if(Q.tail >Q.head)
	{
		for(int i = Q.head; i < Q.tail ; i++)
		{
			std::cout<<"第"<<k++<<"个元素值为："<<Q.data[i]<<std::endl;
		}
	}
	else
	{
		for(int i = Q.head; i < MaxCapacity ; i++)
		{
			std::cout<<"第"<<k++<<"个元素值为："<<Q.data[i]<<std::endl;
		}

		for(int i = 0; i < Q.tail ; i++)
		{
			std::cout<<"第"<<k++<<"个元素值为："<<Q.data[i]<<std::endl;
		}
	}

	return OK;
}