數據結構（C語言）實現循環隊列

//頭文件

#ifndef QUENE_H_INCLUDED
#define QUENE_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CQSIZE 4

typedef int ElemType ;

typedef struct
{
    ElemType* Qbase ;
    ElemType* front ;
    ElemType* rear ;
} CirculQuene ;

int InitQuene( CirculQuene* Q ) ;
int DestroyQuene( CirculQuene* Q ) ;
int IsEmptyQuene( CirculQuene* Q ) ;
int ClearQuene( CirculQuene* Q ) ;
int GetHeadQuene( CirculQuene* Q  , ElemType* e ) ;
int GetLengthQuene( CirculQuene* Q ) ;
int InsertQuene( CirculQuene* Q , ElemType e ) ;
int DeleteQuene( CirculQuene* Q , ElemType* e ) ;
int TraverseQuene( CirculQuene* Q ) ;

#endif // QUENE_H_INCLUDED

//函數實現

 

#include "quene.h"

int InitQuene( CirculQuene* Q )
{
    Q->Qbase = ( ElemType* )malloc( CQSIZE * sizeof( ElemType ) ) ;
    if( !Q->Qbase )
    {
        printf( "OVERFLOW!\n") ;
        exit( 1 ) ;
    }
    memset( Q->Qbase , 0 ,CQSIZE * sizeof( ElemType ) ) ;
    Q->front = Q->Qbase ;
    Q->rear = Q->Qbase ;
    return 0 ;
}

int DestroyQuene( CirculQuene* Q )
{
    ElemType* p = Q->Qbase ;
    ElemType* q =NULL ;
    Q->front = NULL ;
    Q->rear = NULL ;
    while( p < Q->Qbase + CQSIZE )
    {
        q = p++ ;
        free( q ) ;
    }
    free( Q->Qbase ) ;
    return 0 ;
}

int IsEmptyQuene( CirculQuene* Q )
{
    if( Q->front == Q->rear )
    {
        return 1 ;
    }
    return 0 ;
}

int ClearQuene( CirculQuene* Q )
{
    Q->front = Q->Qbase ;
    Q->rear = Q->Qbase ;
    memset( Q->Qbase , 0 , CQSIZE * sizeof( ElemType ) ) ;
    return 0 ;
}

int GetHeadQuene( CirculQuene* Q  , ElemType* e )
{
    *e = *Q->front ;
    return 0 ;
}

int GetLengthQuene( CirculQuene* Q )
{
    return ( Q->rear - Q->front + 1 +CQSIZE ) / CQSIZE ;
}

int InsertQuene( CirculQuene* Q , ElemType e )//分類依據：是否是最後一個，是否滿
{
    if( Q->rear != Q->Qbase + CQSIZE - 1 )
    {
        if( Q->rear +1 != Q->front )
        {
            *Q->rear++ = e ;
        }
        else
        {
            printf( "The quene is full!\n" ) ;
            exit( 1 ) ;
        }
    }
    else
    {
        if( Q->front == Q->Qbase )
        {
            printf( "The quene is full!\n" ) ;
            exit( 1 ) ;
        }
        else
        {
            *Q->rear = e ;
            Q->rear = Q->Qbase ;
        }
    }
    return 0 ;
}

int DeleteQuene( CirculQuene* Q , ElemType* e )
{
    if( IsEmptyQuene( Q ) )
    {
        printf( "The quene is empty , fail to delete !\n" ) ;
        exit( 1 ) ;
    }
    else
    {
        *e = *Q->front ;
        if( Q->front == Q->Qbase + CQSIZE - 1 )
        {
            Q->front = Q->Qbase ;
        }
        else
        {
            Q->front++ ;
        }
    }
    return 0 ;
}

int TraverseQuene( CirculQuene* Q )
{
    if( !Q->Qbase )
    {
        printf( "OVERFLOW!\n" ) ;
        exit( 1 ) ;
    }
    ElemType* p = Q->front ;
    while( p != Q->rear )
    {
        if( p == Q->Qbase + CQSIZE - 1 )
        {
            printf( "%d\t" , *p ) ;
            p = Q->Qbase ;
        }
        else
        {
            printf( "%d\t" , *p++ ) ;
        }

    }
    return 0 ;
}

//主函數測試

#include "quene.h"

int main()
{
    CirculQuene Q ;
    ElemType e = 0 ;
    InitQuene( &Q ) ;
    InsertQuene( &Q , 3 ) ;
    InsertQuene( &Q , 5 ) ;
    InsertQuene( &Q , 7 ) ;
    DeleteQuene( &Q , &e ) ;
    DeleteQuene( &Q , &e ) ;
    InsertQuene( &Q , 9 ) ;
    InsertQuene( &Q , 9 ) ;
    //InsertQuene( &Q , 5 ) ;
    printf( "%d\n" , e ) ;
    TraverseQuene( &Q ) ;
    return 0;
}

//歡迎批評指正