【数据结构与算法基础】以数组实现的循环队列 / Circular Queue implemented by array

/********************************************************************
	File:      ArrayQueue.h
	Author:    blackboy, blackboycpp@gmail.com
	Purpose:   循环队列ADT，数组实现
	Created:   2011-04-01
	Modified:  2011-04-01  16:43
*********************************************************************/

#ifndef  __ARRAY_QUEUE_H__
#define  __ARRAY_QUEUE_H__

typedef int ElementType;
struct _Node;
typedef struct _Node Node;
typedef Node* Queue;

struct _Node
{
	int  Capacity;
	int  Size;
	int  Front;
	int  Rear;
	ElementType*  Array;
};

//////////////////////////////////////////////////////////////////////////

Queue  CreateQueue(int);
void  DisposeQueue(Queue);
void  MakeEmpty(Queue);
void  EnQueue(ElementType, Queue);
void  DeQueue(Queue);
ElementType Front(Queue);
int  IsEmpty(Queue);
int  IsFull(Queue);

#endif

#include <stdlib.h>
#include "ArrayQueue.h"

Queue  CreateQueue(int maxElement)
{
	Queue Q = (Queue)malloc(sizeof(Node));
	Q->Array = (ElementType*)malloc(sizeof(ElementType) * maxElement);
	Q->Capacity = maxElement;
	MakeEmpty(Q);
	return Q;
}

void  DisposeQueue(Queue Q)
{	
	if(Q != NULL)
	{
		free(Q->Array);
		free(Q);
	}
}

void  MakeEmpty(Queue Q)
{
	Q->Front = 0;
	Q->Rear = -1;	// 注意是-1
	Q->Size = 0;
}

void  EnQueue(ElementType X, Queue Q)
{
	if(IsFull(Q))	return;
	if( Q->Rear == (Q->Capacity-1))		// 回绕
		Q->Rear = -1;
	
	Q->Array[++Q->Rear] = X;	// 注意下标先自增1
	Q->Size++;
}

void  DeQueue(Queue Q)
{
	if(IsEmpty(Q))	return;
	if(Q->Front == (Q->Capacity-1))		// 回绕
		Q->Front = 0;
	else Q->Front++;
	Q->Size--;
}

ElementType Front(Queue Q)
{
	if(!IsEmpty(Q))	
		return Q->Array[Q->Front];
	else
		return -1;
}

int  IsEmpty(Queue Q)
{
	return Q->Size == 0;
}

int  IsFull(Queue Q)
{
	return Q->Size == Q->Capacity;
}

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

#define MAX_ELEMENTS 5

int main()
{
	Queue Q;
	int val;

	Q = CreateQueue(MAX_ELEMENTS);

	EnQueue(1, Q);
	EnQueue(2, Q);
	EnQueue(3, Q);
	EnQueue(4, Q);
	EnQueue(5, Q);

	/* 
		1 2 3 4 5
		*       *
		f       r
	*/
	printf("is full? %d/n", IsFull(Q));
	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	DeQueue(Q);

	/* 
		1 2 3 4 5
		  *     *
		  f     r
	*/
	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	EnQueue(6, Q);

	/* 
		6 2 3 4 5
		* *      
		r f
	*/
	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	DeQueue(Q);
	DeQueue(Q);
	DeQueue(Q);
	DeQueue(Q);

	/* 
		6 2 3 4 5
	    *      
	   f/r
	*/
	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	DeQueue(Q);

	/* 
		6 2 3 4 5
	    * *     
	    r f
	*/
	printf("is empty?: %d/n", IsEmpty(Q));
	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	EnQueue(7, Q);
	EnQueue(8, Q);

	/* 
		6 7 8 4 5
	      * *   
	      f r
	*/
	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	DeQueue(Q);
	DeQueue(Q);

	printf("front: %d, rear: %d/n", Front(Q), Q->Array[Q->Rear]);

	DisposeQueue(Q);

	system("PAUSE");
	return 0;
}