顺序队（C语言实现）

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define QueueSize 100     //    队列所能存储的最大元素个数 
typedef int DataType;
typedef struct
{
    DataType data[QueueSize];    //    数组存储队列元素 
    int front;                   //    队头 
    int rear;                    //    队尾 
    
}SqQueue;

bool Init_Queue(SqQueue * Q);             //    初始队列 
bool Clear_Queue(SqQueue * Q);            //    清空队列 
bool En_Queue(SqQueue * Q, DataType x);   //    入队 
bool De_Queue(SqQueue * Q, DataType* x);  //    出队    
int GetHead_Queue(SqQueue * Q);           //    读队头元素 
bool Empty_Queue(SqQueue * Q);            //    判空 
bool Full_Queue(SqQueue * Q);             //    判满 
int Length_Queue(SqQueue * Q);            //    队列长度 
void Traverse_Queue(SqQueue * Q);         //    遍历队列 

int main()
{
    char ch;
    DataType x;
    int i,n,val;
    SqQueue Q;
    
    if(Init_Queue(&Q))
        printf("队列初始化成功！\n");
    else
        printf("队列初始化失败！\n");
         
         
    printf("请输入要入队的元素个数:");
    scanf("%d",&n);
    for(i = 0; i<n; ++i)
    {
        printf("第%d个入队的元素:",i+1);
        scanf("%d",&val);
        En_Queue(&Q, val);
    }
    printf("遍历队列:");
    Traverse_Queue(&Q);
    
    printf("\n队头元素：%d\n", GetHead_Queue(&Q)); 
    printf("遍历队列:");
    Traverse_Queue(&Q);
    
    printf("\n队列长度:%d\n\n", Length_Queue(&Q)); 
    
    do
    {
        fflush(stdin);//    清空输入缓冲区
        if(De_Queue(&Q, &x))
        {
        printf("出队成功！\n");
        printf("出队的元素:%d\n", x);
        } 
        else
            printf("出队失败！\n");

        printf("是否还需要将元素出队？（输入F结束）：");
        ch = getchar();    //    读取字符的同时读取空格符 
            
    }while(ch!='F');
    printf("遍历队列:");
    Traverse_Queue(&Q);
     
    if(Clear_Queue(&Q))
        printf("\n队列清空成功！\n");
    else
        printf("\n队列清空失败！\n");    
    printf("遍历队列:");
    Traverse_Queue(&Q);    
    
    return 0 ; 
}

bool Init_Queue(SqQueue * Q)
{
    Q->front = Q->rear = 0;
    return true; 
}

bool Clear_Queue(SqQueue * Q)    //    数组静态分配内存，无需销毁 
{
    Q->front = Q->rear;
    return true;
}

bool En_Queue(SqQueue * Q, DataType x)
{
    if(Full_Queue(Q))
        return false;
         
    Q->data[Q->rear] = x;                    //    尾指针永远指向最后一个有效元素的下一个位置 
    Q->rear = (Q->rear + 1) % QueueSize;    //    确保不会越界，形成循环队列 
    return true;
}

bool De_Queue(SqQueue * Q, DataType * x)
{
    if(Empty_Queue(Q))
        return false;
        
    *x = Q->data[Q->front];
    Q->front = (Q->front + 1) % QueueSize;    //    确保不会越界，形成循环队列 
    return true;
}

int GetHead_Queue(SqQueue * Q)
{
    return Q->data[Q->front];    
} 

bool Empty_Queue(SqQueue * Q)
{
    if(Q->front==Q->rear)
        return true;
    else
        return false;
}

bool Full_Queue(SqQueue * Q)
{
    if(Q->rear+1%QueueSize==Q->front)
        return true;
    else
        return false;

} 

int Length_Queue(SqQueue * Q)
{
    int i = Q->front;    //    队头指针不能被修改 
    int len = 0;
    
    while(i!=Q->rear)
    {
        len++;    
        i = (i + 1)%QueueSize;    
    } 
    
    return len;
}

void Traverse_Queue(SqQueue * Q)
{
    int i  = Q->front;    //    从队头开始遍历
    
    while(i!=Q->rear)
    {
        printf("%3d", Q->data[i]);
        i = (i + 1)%QueueSize;
    } 
    
    printf("\n");
}