队列

• 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

  队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表

代码

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

/************************************************************************/
/* 队列

	  结构要素：队列容量  内存指针  元素个数  队列头  对列尾

	*/
/************************************************************************/

#define QUEUE_CAPACITY 3    //队列容量

typedef struct tag_queue
{
	int *pQueue;   //队列内存指针
	int head;      //队列头
	int tail;      //队列尾
	int length;    //元素个数
}LineQueue;

int InitQueue(LineQueue **myQueue);               //InitQueue(&Q)             创建队列
void DestroyQueue(LineQueue *myQueue);           //DestroyQueue(&Q)          销毁队列
void ClearQueue(LineQueue *myQueue);             //ClearQueue(&Q)            清空队列
int QueueEmpty(LineQueue *myQueue);              //QueueEmpty(&Q)            判空队列
int QueueFull(LineQueue *myQueue);               //QueueFull(&Q)             判满队列
int QueueLength(LineQueue *myQueue);             //QueueLength(&Q)           队列长度
int EnQueue(LineQueue *myQueue, int element);    //EnQueue(&Q, element)      新元素入队
int DeQueue(LineQueue *myQueue, int *element);   //DeQueue(&Q, &element)     首元素出队
void QueueTraverse(LineQueue *myQueue);          //QueueTraverse(Q, visit()) 遍历队列

int InitQueue(LineQueue **myQueue)
{
	(*myQueue) = (LineQueue *)malloc(sizeof(LineQueue));
	//printf("queue1 = %p\n", (*myQueue));
	if(myQueue == NULL)
	{
		return 0;
	}
	(*myQueue)->pQueue = (int *)malloc(sizeof(int) * QUEUE_CAPACITY);
	if((*myQueue)->pQueue == NULL)
	{
		return 0;
	}
	(*myQueue)->head = 0;
	(*myQueue)->tail = 0;
	(*myQueue)->length = 0;

	return 1;
}

void DestroyQueue(LineQueue *myQueue)
{
	free(myQueue->pQueue);
	myQueue->pQueue = NULL;
	free(myQueue);
	myQueue = NULL;
}

void ClearQueue(LineQueue *myQueue)
{
	myQueue->length = 0;
	myQueue->tail = 0;
}

int QueueEmpty(LineQueue *myQueue)
{
	if(myQueue->length == 0)
	{
		return 1;
	}
	return 0;
}

int QueueFull(LineQueue *myQueue)
{
	if(myQueue->length >= QUEUE_CAPACITY)
	{
		return 1;
	}
	return 0;
}

int QueueLength(LineQueue *myQueue)
{
	return myQueue->length;
}

int EnQueue(LineQueue *myQueue, int element)
{
	if(QueueFull(myQueue))
	{
		return 0;
	}
	myQueue->pQueue[myQueue->tail] = element;
	myQueue->tail++;
	myQueue->length++;
	return 1;
}

int DeQueue(LineQueue *myQueue, int *element)
{
	int i = 0;
	if(QueueEmpty(myQueue))
	{
		return 0;
	}
	*element = myQueue->pQueue[myQueue->head];

	for(i = 1; i < myQueue->length; i++)
	{
		myQueue->pQueue[i-1] = myQueue->pQueue[i];
	}
	myQueue->length--;
	myQueue->tail--;
	return 1;
}

void QueueTraverse(LineQueue *myQueue, int flag)
{
	int i = 0;
	if(flag == 0)  //从头到尾
	{
		for(i = 0; i < myQueue->length; i++)
		{
			printf("%d ", myQueue->pQueue[i]);
		}
	}
	
	if(flag == 1)  //从尾到头
	{
		for(i = myQueue->length - 1; i >= 0; i--)
		{
			printf("%d ", myQueue->pQueue[i]);
		}
	}
}

int main(void)
{
	int elem = 0;
	LineQueue *queue = NULL;
	InitQueue(&queue);

	if(QueueEmpty(queue))
	{
		printf("当前队列为空\n");
	}

	EnQueue(queue, 2);
	EnQueue(queue, 4);
	EnQueue(queue, 5);

	if(QueueFull(queue))
	{
		printf("当前队列为满\n");
	}

	QueueTraverse(queue, 0);

	printf("\n-----------------------\n");

	
	/*DeQueue(queue, &elem);
	printf("elem = %d\n", elem);

	DeQueue(queue, &elem);
	printf("elem = %d\n", elem);

	DeQueue(queue, &elem);
	printf("elem = %d\n", elem);*/

	printf("queueLength = %d\n", QueueLength(queue));

	ClearQueue(queue);

	if(QueueEmpty(queue))
	{
		printf("当前队列为空\n");
	}

	//QueueTraverse(queue, 1);

	//printf("queue2 = %p\n", queue);
	DestroyQueue(queue);

	system("pause");
	return 0;
}

注意事项

• %p 打印地址信息

我的代码

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

#define QUEUE_CAPACITY 3 //队列容量

typedef struct tag_queue{
    int *pQueue;
    int head;
    int tail;
    int length;
}LineQueue;

int InitQueue(LineQueue **myQueue);               //InitQueue(&Q)             创建队列
void DestroyQueue(LineQueue *myQueue);           //DestroyQueue(&Q)          销毁队列
void ClearQueue(LineQueue *myQueue);             //ClearQueue(&Q)            清空队列
int QueueEmpty(LineQueue *myQueue);              //QueueEmpty(&Q)            判空队列
int QueueFull(LineQueue *myQueue);               //QueueFull(&Q)             判满队列
int QueueLength(LineQueue *myQueue);             //QueueLength(&Q)           队列长度
int EnQueue(LineQueue *myQueue, int element);    //EnQueue(&Q, element)      新元素入队
int DeQueue(LineQueue *myQueue, int *element);   //DeQueue(&Q, &element)     首元素出队
void QueueTraverse(LineQueue *myQueue,int flag);          //QueueTraverse(Q, visit()) 遍历队列


int main(){
    //单元测试
    LineQueue *queue = nullptr;
    InitQueue(&queue);
    printf("queue out = %p\n",queue);
    if (QueueEmpty(queue)){
        printf("当前队列为空\n");
    }
    EnQueue(queue,2);
    EnQueue(queue,4);
    EnQueue(queue,5);
    if (QueueEmpty(queue)){
        printf("当前队列为空\n");
    }
    QueueTraverse(queue,0);
    printf("\n");
    QueueTraverse(queue,1);
    printf("\n");
    int elem = 0;
    DeQueue(queue,&elem);
    printf("elem = %d \n", elem);
    QueueTraverse(queue,0);
    DestroyQueue(queue);
    return 0;
}
int InitQueue(LineQueue **myQueue){
    //InitQueue(&Q)             创建队列
    *myQueue = static_cast<LineQueue *>(malloc(sizeof(LineQueue)));//单个
    printf("queue in = %p\n",(*myQueue));
    //给所有容量分配内存
    (*myQueue)->pQueue = static_cast<int *>(malloc(sizeof(int ) * QUEUE_CAPACITY));
    (*myQueue)->head = 0;
    (*myQueue)->tail = 0;
    (*myQueue)->length = 0;
    if (myQueue == nullptr){
        return 0;
    }else
        return 1;
}

void DestroyQueue(LineQueue *myQueue){
    free(myQueue->pQueue);
    myQueue->pQueue = nullptr;
    free(myQueue);
    myQueue = nullptr;
}

void ClearQueue(LineQueue *myQueue){
    myQueue->length = 0;
    myQueue->tail = 0;
}

int QueueEmpty(LineQueue *myQueue){
    if (myQueue->length == 0){
        return 1;
    }
    return 0;
}

int QueueFull(LineQueue *myQueue){
    if (myQueue->length == QUEUE_CAPACITY){
        return 1;
    }
    return 0;
}

int QueueLength(LineQueue *myQueue){
    return myQueue->length;
}

int EnQueue(LineQueue *myQueue, int element)
{
    if(QueueFull(myQueue))
    {
        return 0;
    }
    myQueue->pQueue[myQueue->tail] = element;
    myQueue->tail++;
    myQueue->length++;
    return 1;
}

int DeQueue(LineQueue *myQueue, int *element){
    if (QueueEmpty(myQueue)){
        return 0;
    }
    *element = myQueue->pQueue[myQueue->head];
    for (int i = 1; i < myQueue->length; ++i) {
        myQueue->pQueue[i-1] = myQueue->pQueue[i];
    }
    myQueue->length--;
    myQueue->tail--;
}

void QueueTraverse(LineQueue *myQueue,int flag){
    if (flag == 0){
        //从头到尾
        for (int i = 0; i < myQueue->length; ++i) {
            printf("%d ",myQueue->pQueue[i]);
        }
    }
    if (flag == 1){
        //从尾到头
        for (int i = myQueue->length-1; i >=0; --i) {
            printf("%d ",myQueue->pQueue[i]);
        }
    }
}

环形队列

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

#define QUEUE_CAPACITY 3 //队列容量

typedef struct tag_queue{
    int *pQueue;
    int head;
    int tail;
    int length;
}RingQueue;

int InitQueue(RingQueue **myQueue);               //InitQueue(&Q)             创建队列
void DestroyQueue(RingQueue *myQueue);           //DestroyQueue(&Q)          销毁队列
void ClearQueue(RingQueue *myQueue);             //ClearQueue(&Q)            清空队列
int QueueEmpty(RingQueue *myQueue);              //QueueEmpty(&Q)            判空队列
int QueueFull(RingQueue *myQueue);               //QueueFull(&Q)             判满队列
int QueueLength(RingQueue *myQueue);             //QueueLength(&Q)           队列长度
int EnQueue(RingQueue *myQueue, int element);    //EnQueue(&Q, element)      新元素入队
int DeQueue(RingQueue *myQueue, int *element);   //DeQueue(&Q, &element)     首元素出队
void QueueTraverse(RingQueue *myQueue,int flag);          //QueueTraverse(Q, visit()) 遍历队列


int main(){
    //单元测试
    RingQueue *queue = nullptr;
    InitQueue(&queue);
    printf("queue out = %p\n",queue);
    if (QueueEmpty(queue)){
        printf("当前队列为空\n");
    }
    EnQueue(queue,2);
    EnQueue(queue,4);
    EnQueue(queue,5);
    if (QueueEmpty(queue)){
        printf("当前队列为空\n");
    }
    QueueTraverse(queue,0);
    printf("\n");
    QueueTraverse(queue,1);
    printf("\n");
    int elem = 0;
    DeQueue(queue,&elem);
    printf("elem = %d \n", elem);
    QueueTraverse(queue,0);
    DestroyQueue(queue);
    return 0;
}
int InitQueue(RingQueue **myQueue){
    //InitQueue(&Q)             创建队列
    *myQueue = static_cast<RingQueue *>(malloc(sizeof(RingQueue)));//单个
    printf("queue in = %p\n",(*myQueue));
    //给所有容量分配内存
    (*myQueue)->pQueue = static_cast<int *>(malloc(sizeof(int ) * QUEUE_CAPACITY));
    (*myQueue)->head = 0;
    (*myQueue)->tail = 0;
    (*myQueue)->length = 0;
    if (myQueue == nullptr){
        return 0;
    }else
        return 1;
}

void DestroyQueue(RingQueue *myQueue){
    free(myQueue->pQueue);
    myQueue->pQueue = nullptr;
    free(myQueue);
    myQueue = nullptr;
}

void ClearQueue(RingQueue *myQueue){
    myQueue->length = 0;
    myQueue->tail = 0;
    myQueue->head = 0;
}

int QueueEmpty(RingQueue *myQueue){
    if (myQueue->length == 0){
        return 1;
    }
    return 0;
}

int QueueFull(RingQueue *myQueue){
    if (myQueue->length == QUEUE_CAPACITY){
        return 1;
    }
    return 0;
}

int QueueLength(RingQueue *myQueue){
    return myQueue->length;
}

int EnQueue(RingQueue *myQueue, int element)
{
    if(QueueFull(myQueue))
    {
        return 0;
    }
    myQueue->pQueue[myQueue->tail] = element;
    myQueue->tail++;
    myQueue->tail %= QUEUE_CAPACITY;
    myQueue->length++;
    return 1;
}

int DeQueue(RingQueue *myQueue, int *element){
    if (QueueEmpty(myQueue)){
        return 0;
    }
    *element = myQueue->pQueue[myQueue->head];
    myQueue->head %= QUEUE_CAPACITY;  
    myQueue->length--;
    myQueue->tail--;
}

void QueueTraverse(RingQueue *myQueue,int flag){
    if (flag == 0){
        //从头到尾
        for (int i = 0; i < myQueue->length + myQueue->head; ++i) {
            printf("%d ",myQueue->pQueue[i % QUEUE_CAPACITY]);
        }
    }
    if (flag == 1){
        //从尾到头
        for (int i = myQueue->tail -1; i >=myQueue->tail - myQueue->length; --i) {
            printf("%d ",myQueue->pQueue[(i + QUEUE_CAPACITY) % QUEUE_CAPACITY]);
        }
    }
}

环形队列 存储 学生信息结构体

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

#define QUEUE_CAPACITY 3 //队列容量

typedef struct tag_student{
    char name[30];
    int age;
}Student;

typedef struct tag_queue{
    Student *pQueue;
    int head;
    int tail;
    int length;
}RingQueue;

int InitQueue(RingQueue **myQueue);               //InitQueue(&Q)             创建队列
void DestroyQueue(RingQueue *myQueue);           //DestroyQueue(&Q)          销毁队列
void ClearQueue(RingQueue *myQueue);             //ClearQueue(&Q)            清空队列
int QueueEmpty(RingQueue *myQueue);              //QueueEmpty(&Q)            判空队列
int QueueFull(RingQueue *myQueue);               //QueueFull(&Q)             判满队列
int QueueLength(RingQueue *myQueue);             //QueueLength(&Q)           队列长度
int EnQueue(RingQueue *myQueue, Student* stu);    //EnQueue(&Q, element)      新元素入队
int DeQueue(RingQueue *myQueue, Student* stu);   //DeQueue(&Q, &element)     首元素出队
void QueueTraverse(RingQueue *myQueue,int flag);          //QueueTraverse(Q, visit()) 遍历队列

void printInfo(Student *stu);//打印结构体信息

int main(){
    //单元测试
    RingQueue *queue = nullptr;
    InitQueue(&queue);
    Student stu1 = {"zhangsan",10};
    if (QueueEmpty(queue)){
        printf("当前队列为空\n");
    }
    EnQueue(queue,&stu1);
    QueueTraverse(queue,0);
    Student stu2{};
    DeQueue(queue,&stu2);
    printInfo(&stu2);
    return 0;
}
int InitQueue(RingQueue **myQueue){
    //InitQueue(&Q)             创建队列
    *myQueue = static_cast<RingQueue *>(malloc(sizeof(RingQueue)));//单个
    printf("queue in = %p\n",(*myQueue));
    //给所有容量分配内存
    (*myQueue)->pQueue = static_cast<Student *>(malloc(sizeof(Student ) * QUEUE_CAPACITY));
    (*myQueue)->head = 0;
    (*myQueue)->tail = 0;
    (*myQueue)->length = 0;
    if (myQueue == nullptr){
        return 0;
    }else
        return 1;
}

void DestroyQueue(RingQueue *myQueue){
    free(myQueue->pQueue);
    myQueue->pQueue = nullptr;
    free(myQueue);
    myQueue = nullptr;
}

void ClearQueue(RingQueue *myQueue){
    myQueue->length = 0;
    myQueue->tail = 0;
    myQueue->head = 0;
}

int QueueEmpty(RingQueue *myQueue){
    if (myQueue->length == 0){
        return 1;
    }
    return 0;
}

int QueueFull(RingQueue *myQueue){
    if (myQueue->length == QUEUE_CAPACITY){
        return 1;
    }
    return 0;
}

int QueueLength(RingQueue *myQueue){
    return myQueue->length;
}

int EnQueue(RingQueue *myQueue, Student* stu)
{
    if(QueueFull(myQueue))
    {
        return 0;
    }
//    myQueue->pQueue[myQueue->tail] = element;
//    strcpy((myQueue->pQueue[myQueue->tail]).name,stu->name);
    strcpy_s((myQueue->pQueue[myQueue->tail]).name,30,stu->name);

    (myQueue->pQueue[myQueue->tail]).age = stu->age;
    myQueue->tail++;
    myQueue->tail %= QUEUE_CAPACITY;
    myQueue->length++;
    return 1;
}

int DeQueue(RingQueue *myQueue, Student *element){
    if (QueueEmpty(myQueue)){
        return 0;
    }
//    *element = myQueue->pQueue[myQueue->head];
//    strcpy(element->name,(myQueue->pQueue[myQueue->head]).name);
    strcpy_s(element->name,30,(myQueue->pQueue[myQueue->head]).name);

    element->age = myQueue->pQueue[myQueue->head].age;
    myQueue->head %= QUEUE_CAPACITY;
    myQueue->length--;
    myQueue->tail--;
}

void QueueTraverse(RingQueue *myQueue,int flag){
    if (flag == 0){
        //从头到尾
        for (int i = 0; i < myQueue->length + myQueue->head; ++i) {
//            printf("%d ",myQueue->pQueue[i % QUEUE_CAPACITY]);
            printInfo(&(myQueue->pQueue[i % QUEUE_CAPACITY]));
            printf("\n");
        }
    }
    if (flag == 1){
        //从尾到头
        for (int i = myQueue->tail -1; i >=myQueue->tail - myQueue->length; --i) {
//            printf("%d ",myQueue->pQueue[(i + QUEUE_CAPACITY) % QUEUE_CAPACITY]);
            printInfo(&(myQueue->pQueue[(i + QUEUE_CAPACITY) % QUEUE_CAPACITY]));
            printf("\n");
        }
    }
}

void printInfo(Student *stu) {
    printf("%s ",stu->name);
    printf("%d ",stu->age);
}

​