顺序结构的循环栈

#ifndef SQQUEUE_H
#define SQQUEUE_H
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

typedef int ElemType;
#define MAXSIZE 5
typedef struct {
    ElemType data[MAXSIZE];
    int front;
    int rear;
}SqQueue;

// 初始化顺序循环队列
void InitSqQueue(SqQueue *q)
{
    memset(q,0,sizeof(*q));
    q->rear =0;
    q->front =0;
}
void DestroySqQueue(SqQueue *q)
{
    free(q);
}
void ClearSqQueue(SqQueue *q)
{
    InitSqQueue(q);
}
bool QueueEmpty(SqQueue *q)
{
    return (q->front == q->rear);
}
// 队列是满的
bool QueueFull(SqQueue *q)
{
    return (q->rear +1)%MAXSIZE == q->front;
}
void PrintSqQueue(SqQueue *q)
{
    printf("front=%d, rear=%d\n", q->front, q->rear);
    if (q->front <= q->rear) {
        for(int i=0; i < q->front; i++){
            printf("* ");
        }
        for(int j=q->front; j < q->rear; j++){
            printf("%d ", q->data[j]);
        }
        for(int k=q->rear; k < MAXSIZE; k++){
            printf("* ");
        }
    }
    else {
        for(int i=0; i < q->rear; i++){
            printf("%d ", q->data[i]);
        }
        for(int j=q->rear; j < q->front; j++){
            printf("* ", q->data[j]);
        }
        for(int k=q->front; k < MAXSIZE; k++){
            printf("%d ", q->data[k]);
        }
    }
    printf("\n");
}

// front向后移一个单位长度，或者掉转到开头
void FrontBackward(int *front)
{
    *front = (*front+1)%MAXSIZE;
}
// rear向后移一个单位长度，或者掉转到开头
void RearBackward(int *rear)
{
    *rear = (*rear+1)%MAXSIZE;
}
// 返回队列头元素给e
void GetHead(SqQueue *q, ElemType *e)
{
    *e = q->data[q->front];
}
// 队尾插入元素
int EnQueue(SqQueue *q, ElemType e)
{
    if (QueueFull(q))
        return -1;
    q->data[q->rear] = e;
    RearBackward(&q->rear);
    return 0;
}
// 队头取出元素
int DeQueue(SqQueue *q, ElemType *e)
{
    if (QueueEmpty(q))
        return -1;
    *e = q->data[q->front];
    q->data[q->front] = 0;
    FrontBackward(&q->front);
    return 0;
}
// 队列中已经有的元素个数
int QueueLength(SqQueue *q)
{
    return (q->rear - q->front + MAXSIZE)%MAXSIZE;
}
#endif // SQQUEUE_H

【一】队列的定义
	1.队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
	2.队列是一种先进先出的线性表简称FIFO，简称FIFO（First In First Out）
	3.允许插入的一端称为队尾，允许删除的一端称为对头。
▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂	  
【二】队列的顺序存储结构---循环队列（循环缓冲区FIFO）
	// 非循环的结构每次删除后都要移动所有元素（不合理）
（1）定义
	1.数组的长度固定（QueueSize），使用两个下标数字（front和rear来模拟循环队列）
	2.front为队列头的下标，rear为队尾的下一个位置的下标
	2.最开始从数组的后面插，前面取。数组插满之后就重头开始插。
	3.rear > front时，说明循环队列还没有开始循环插入；反之，说明已经循环插入了。
	4.当数组中还有一个空闲位置时，认为循环队列满了。
		1.(rear+1)%QueueSize = front 时，队列满了	（未开始循环）
									// 0 1 2 3 4 
									   f . . . r  	
		2..(rear+1)%QueueSize = front 时，队列满了（已经循环了）
									// 0 1 2 3 4 
									   . . r f .	
		==》(rear+1)%QueueSize = front 时，队列满了。
	5.队列的长度
		未循环时：rear-front
		循环时：  （QueueSize - front）+rear = rear-front+QueueSize // 包括两部分：front及后面的，rear前面的
	    ==》队列的长度= （rear-front+QueueSize）%QueueSize
	6.front或者rear往后移一个位置，或者是转到数组开头位置
		front = （front+1）%QueueSize
		rear = （rear+1）%QueueSize
	7.队列为空的条件
		front = rear；
（2）特点
	1.时间复杂度为O（1）	
	2.数组长度固定