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;
}

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