数据结构与算法分析（C语言描述）（十）队列的链表实现&队列的数组实现

1.队列的链表实现

queue.h

typedef int ElementType;

#ifndef _QUEUE_LIST_
#define _QUEUE_LIST_

struct QNode;
struct Node;
typedef struct QNode *QNodePtr;
typedef struct Node *PtrToNode;
typedef PtrToNode Queue;

int IsEmpty(Queue Q);                       //判断队列是否为空Q->Rear == Q->Front;
Queue CreateQueue();                         //构造队列
void DisposeQueue(Queue Q);                //删除整个队列，回收空间
void MakeEmpty(Queue Q);                  //释放队列空间，将其置为空
void EnQueue(ElementType X, Queue Q);     //在队列尾端插入元素
ElementType Front(Queue Q);              //取出对头元素，但不删除
void Dequeue(Queue Q);                   //删除对头元素
ElementType FrontAndDequeue(Queue Q);   //
void PrintQueue(Queue Q);               //打印队列

#endif

queue.c

#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
struct QNode
{
	ElementType Element;
	QNodePtr Next;
};
struct Node
{
	QNodePtr Front;
	QNodePtr Rear;
};
int IsEmpty(Queue Q)
{
	return Q->Rear == Q->Front;
}
void MakeEmpty(Queue Q)
{
	if (Q == NULL)
	{
		printf("The queue is empty! Must use CreateQueue first!\n");
		return;
	}
	else
	{
		while (!IsEmpty(Q))
			Dequeue(Q);
	}
}
Queue CreateQueue(void)
{
	//不仅要为对头(Queue)申请空间，还要为队列元素/节点（QNode）申请空间.
	Queue Q;
	Q = (Queue)malloc(sizeof(struct Node));
	if (Q == NULL)
	{
		printf("Out of space!\n");
		return NULL;
	}
	Q->Front = Q->Rear = (QNodePtr)malloc(sizeof(struct QNode));
	if (Q->Front == NULL)
	{
		printf("Out of space!\n");
		return NULL;
	}
	Q->Front->Next = NULL;
	return Q;
}
void DisposeQueue(Queue Q)
{
	while (Q->Front != NULL)
	{
		Q->Rear = Q->Front->Next;
		free(Q->Front);
		Q->Front = Q->Rear;
	}
}
void Dequeue(Queue Q)
{
	//删除链队列第一个元素
	if (!IsEmpty(Q))
	{
		QNodePtr P;
		P = Q->Front->Next;
		Q->Front->Next = P->Next;
		if (Q->Rear == P)          //判断队列中是否只有一个元素
			Q->Rear = Q->Front;
		free(P);
	}
	else
	{
		printf("The queue is empty!\n");
	}
}
void EnQueue(ElementType X, Queue Q)
{
	QNodePtr P = (QNodePtr)malloc(sizeof(struct QNode));
	if (P == NULL)
	{
		printf("Out of space!\n");
		return;
	}
	else
	{
		P->Next = NULL;
		P->Element = X;
		Q->Rear->Next = P;
		Q->Rear = P;
	}
}
ElementType Front(Queue Q)
{
	return Q->Front->Next->Element;
}
ElementType FrontAndDequeue(Queue Q)
{
	ElementType X = 0;
	if (!IsEmpty(Q))
	{
		X = Front(Q);
		Dequeue(Q);
	}
	else
	{
		printf("The queue is empty!\n");
	}
	return X;
}
void PrintQueue(Queue Q)
{
	QNodePtr P = Q->Front;
	while (P != Q->Rear)
	{
		P = P->Next;
		printf("%d\n", P->Element);
	}
}

testque.c

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

main( )
{
    Queue Q;
    int i;

	Q = CreateQueue(12);
	
    for( i = 0; i < 10; i++ )
        EnQueue( i, Q );

	PrintQueue(Q);

    while( !IsEmpty( Q ) )
    {
        printf( "%d\n", Front( Q ) );
        Dequeue( Q );
    }

    DisposeQueue( Q );
	getchar();
    return 0;
}

2.队列的数组实现

queue.h

        typedef int ElementType;
/* START: fig3_57.txt */
        #ifndef _Queue_h
        #define _Queue_h

        struct QueueRecord;
        typedef struct QueueRecord *Queue;

        int IsEmpty( Queue Q );
        int IsFull( Queue Q );
        Queue CreateQueue( int MaxElements );
        void DisposeQueue( Queue Q );
        void MakeEmpty( Queue Q );
        void Enqueue( ElementType X, Queue Q );
        ElementType Front( Queue Q );
        void Dequeue( Queue Q );
        ElementType FrontAndDequeue( Queue Q );

        #endif  /* _Queue_h */
/* END */

queue.c

        #include "queue.h"
        #include "fatal.h"
        #include <stdlib.h>

        #define MinQueueSize ( 5 )

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

/* START: fig3_58.txt */
        int
        IsEmpty( Queue Q )
        {
            return Q->Size == 0;
        }
/* END */

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

        Queue
        CreateQueue( int MaxElements )
        {
            Queue Q;

/* 1*/      if( MaxElements < MinQueueSize )
/* 2*/          Error( "Queue size is too small" );

/* 3*/      Q = malloc( sizeof( struct QueueRecord ) );
/* 4*/      if( Q == NULL )
/* 5*/          FatalError( "Out of space!!!" );

/* 6*/      Q->Array = malloc( sizeof( ElementType ) * MaxElements );
/* 7*/      if( Q->Array == NULL )
/* 8*/          FatalError( "Out of space!!!" );
/* 9*/      Q->Capacity = MaxElements;
/*10*/      MakeEmpty( Q );

/*11*/      return Q;
        }

/* START: fig3_59.txt */
        void
        MakeEmpty( Queue Q )
        {
            Q->Size = 0;
            Q->Front = 1;
            Q->Rear = 0;
        }
/* END */

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

/* START: fig3_60.txt */

        static int
        Succ( int Value, Queue Q )
        {
            if( ++Value == Q->Capacity )
                Value = 0;
            return Value;
        }

        void
        Enqueue( ElementType X, Queue Q )
        {
            if( IsFull( Q ) )
                Error( "Full queue" );
            else
            {
                Q->Size++;
                Q->Rear = Succ( Q->Rear, Q );
                Q->Array[ Q->Rear ] = X;
            }
        }
/* END */



        ElementType
        Front( Queue Q )
        {
            if( !IsEmpty( Q ) )
                return Q->Array[ Q->Front ];
            Error( "Empty queue" );
            return 0;  /* Return value used to avoid warning */
        }

        void
        Dequeue( Queue Q )
        {
            if( IsEmpty( Q ) )
                Error( "Empty queue" );
            else
            {
                Q->Size--;
                Q->Front = Succ( Q->Front, Q );
            }
        }

        ElementType
        FrontAndDequeue( Queue Q )
        {
            ElementType X = 0;

            if( IsEmpty( Q ) )
                Error( "Empty queue" );
            else
            {
                Q->Size--;
                X = Q->Array[ Q->Front ];
                Q->Front = Succ( Q->Front, Q );
            }
            return X;
        }

testque.c

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

main( )
{
    Queue Q;
    int i;

	Q = CreateQueue(12);
	
    for( i = 0; i < 10; i++ )
        EnQueue( i, Q );

	PrintQueue(Q);

    while( !IsEmpty( Q ) )
    {
        printf( "%d\n", Front( Q ) );
        Dequeue( Q );
    }

    DisposeQueue( Q );
	getchar();
    return 0;
}