C实现简单循环队列

//SqQueue.h

#ifndef SQQUEUE_H
#define SQQUEUE_H

#include <stdlib.h>
#include <stdio.h>
#define QUEUE_SIZE 8
//#define NULL 0x00

struct _Node
{
	int iValue;
};

typedef struct _Node Node;

typedef struct
{
	Node* pBase;
	int iFront;
	int iRear;
	int iSize;
}SqQueue;
#endif

//SqQueue.c

#include "SqQueue.h"

SqQueue* InitQueue()
{
	SqQueue* pQueue = (SqQueue*)malloc( sizeof( SqQueue ));

	if( !pQueue )
		return NULL;

	pQueue->pBase = (Node*)malloc( sizeof( Node ) * QUEUE_SIZE );

	if( !pQueue->pBase )
		return NULL;

	pQueue->iFront  =  0;
	pQueue->iRear = 0;
	pQueue->iSize = 0;

	return pQueue;
}

int QueueLength( SqQueue* pQueue )
{
	if( !pQueue )
		return 0;

	return pQueue->iSize;
}

void PrintNode( Node* pNode )
{
	if( !pNode )
		return;

	printf( "%d ", pNode->iValue );
}

int EnQueue( SqQueue* pQueue, Node* pNode )
{
	if( !pQueue || !pNode )
		return -1;

	if( pQueue->iSize == QUEUE_SIZE )
	{
		puts( "Queue full!" );

		return -2;
	}

	( pQueue->pBase + pQueue->iRear )->iValue = pNode->iValue;

	pQueue->iRear = ( pQueue->iRear + 1 ) % QUEUE_SIZE;

	pQueue->iSize++;
	
	return 0;
}


Node* DeQueue( SqQueue* pQueue )
{
	if( !pQueue || pQueue->iSize == 0 )
		return NULL;

	pQueue->iFront = ( pQueue->iFront + 1 ) % QUEUE_SIZE;

	pQueue->iSize--;

	return pQueue->pBase + ( QUEUE_SIZE + pQueue->iFront - 1 ) % QUEUE_SIZE;	
}

void ClearQueue( SqQueue* pQueue )
{
	if( !pQueue )
		return;

	free( pQueue->pBase );
	pQueue->pBase = NULL;

	pQueue->iSize = 0;
	pQueue->iFront = 0;
	pQueue->iRear = 0;
}

void DestroyQueue( SqQueue** pQueue )
{
	if( !(*pQueue ) )
		return;

	ClearQueue( *pQueue );

	free( *pQueue );

	*pQueue = NULL;
}

Node* CreateNode( int iValue )
{
	Node* pNode = (Node*)malloc( sizeof( Node ) );

	if( !pNode )
		return NULL;

	pNode->iValue = iValue;

	return pNode;
}

void QueueTraverse( SqQueue* pQueue )
{
	if( !pQueue || 0 == pQueue->iSize )
		return;

	int i  = pQueue->iFront;

	int iEnd = (pQueue->iRear - 1 + QUEUE_SIZE) % QUEUE_SIZE;

	puts( "" );
	if(  iEnd >= i )
	{
		for( ; i <= iEnd; i++ )
		{
			PrintNode( pQueue->pBase + i );
		}
	}
	else
	{
		for( ; i <  QUEUE_SIZE; i++ )
		{
			PrintNode( pQueue->pBase + i );
		}

		for( i = 0; i <= iEnd; i++ )
		{
			PrintNode( pQueue->pBase + i );
		}
	}

	puts( "" );
}

int main( int argc, char* argv[] )
{
	SqQueue* pQueue = InitQueue();

	EnQueue( pQueue, CreateNode( 1 ) );
	EnQueue( pQueue, CreateNode( 2 ) );
	EnQueue( pQueue, CreateNode( 3 ) );
	EnQueue( pQueue, CreateNode( 4 ) );
	EnQueue( pQueue, CreateNode( 5 ) );
	EnQueue( pQueue, CreateNode( 6 ) );
	EnQueue( pQueue, CreateNode( 7 ) );
	EnQueue( pQueue, CreateNode( 8 ) );

	QueueTraverse( pQueue );

	puts( "DeQueue..." );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );

	PrintNode( DeQueue( pQueue ) );
	PrintNode( DeQueue( pQueue ) );

	
	puts( "\nEnQueue 9 ..." );
	EnQueue( pQueue, CreateNode( 9 ) );
	EnQueue( pQueue, CreateNode( 10 ));
	EnQueue( pQueue, CreateNode( 11 ));
	EnQueue( pQueue, CreateNode( 12 ));
	EnQueue( pQueue, CreateNode( 13 ));
	EnQueue( pQueue, CreateNode( 14 ));
	EnQueue( pQueue, CreateNode( 15 ));
	EnQueue( pQueue, CreateNode( 16 ));
	EnQueue( pQueue, CreateNode( 17 ));
	EnQueue( pQueue, CreateNode( 18 ));

	DeQueue( pQueue );
	DeQueue( pQueue );

	QueueTraverse( pQueue );

	DestroyQueue( &pQueue );

	QueueTraverse( pQueue );

	return 0;
}

makefile

default: a.out
	./a.out

run: a.out
	./a.out

clean: a.out
	rm a.out

a.out: SqQueue.c SqQueue.h
	gcc *.c

rebuild: SqQueue.h SqQueue.c
	gcc *.c

debug: 
	gcc -g SqQueue.c
	gdb a.out