【数据结构】

队列

什么是队列及队列的特点

队列：是先进先出的数据结构体（FIFO）,队列有队头和队尾的概念。队尾是入队的位置，队头是出队的位置。

队列的种类

队列分为：顺序队列，循环队列，链式队列。

顺序队列的特点

顺序队列是通过数组实现的，通过front记录的是队列头的位置，通过rear记录的是队尾的位置，入队的时候rear向后走，出队的时候front向后走，当front=rear的时候队列是空。
但是front向后走之前前面的内存空间就不能够再次访问，所以对于顺序队列来说，在实际的工作开发过程中是不使用（复用性比较差）

循环队列

循环队列的结构及原理

循环队列也是顺序队列的一种，只不过它通过一些算法实现了复用的功能。

上述的循环队列的数据的个数是7，在去向里面存放数据的时候这样来判断。rear+1 % N+1 == front 说明满了就不向里面存数据了，否则没有满向内部存入数据。如果front== rear说明队列是空的，就不能从内部出队了。

入队：
假如最开始的时候队列是空的front = rear = 0;

0+1%8 == 1 != 0 data[0]=10

1+1%8 == 2 != 0 data[1]=20

2+1%8 == 3 != 0 data[2]=30

3+1%8 == 4 != 0 data[3]=20

4+1%8 == 5 != 0 data[4]=20

5+1%8 == 6 != 0 data[5]=20

6+1%8 == 7 != 0 data[6]=20

7+1%8 == 0 == 0 队列已经满了，data[7]是不存放数据的
如果通过上述的步骤让队列存满了，这时候front出队了成员,front=1

7+1%8 == 0 != 1 说明队列没有满，将数据存放在data[7]中
0+1%8 == 1 == 1 队列已经满了，data[0]是不存放数据的

如果通过上述的步骤让队列存满了，这时候front出队了成员，front=2

0+1%8 == 1 != 2 说明队列没有满，将数据存放在data[0]中
1+1%8 == 2 == 2 队列已经满了，data[1]是不存放数据的

循环队列结构体定义

#define N 5
#define datatype int
typedef struct{
   
    datatype data[N+1];
    int front,rear;
}loopqueue_t;

循环队列的操作

1.创建 2.判满 3.入队 4.判空 5.出队 6.遍历
loopqueue.h

#ifndef __LOOPQUEUE_H__
#define __LOOPQUEUE_H__

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

#define N 5
#define datatype int
typedef struct{
   
    datatype data[N+1];
    int front,rear;
}loopqueue_t;

loopqueue_t * LoopQueueCreate(void);
int LoopQueueIsFull(loopqueue_t *h);
int LoopQueueEnQueue(loopqueue_t *h,datatype data);
int LoopQueueIsEmpty(loopqueue_t *h);
datatype LoopQueueDeQueue(loopqueue_t *h);
void LoopQueueShow(loopqueue_t*h);
#endif

loopqueue.c

#include "loopqueue.h"

loopqueue_t* LoopQueueCreate(void)
{
   
    loopqueue_t* h;
    h = (loopqueue_t*)malloc(sizeof(*h));
    if (h == NULL) {
   
        printf("malloc error\n");
        return NULL;
    }
    // 从arr这个地址开始，将向后的50个字节的内存中的值都设置为0
    //  char arr[50];
    // memset(arr,0,sizeof(arr));
    memset(h->data, 0, sizeof(datatype)*(N + 1));
    h->front = h->rear = 0;

    return h;
}
int LoopQueueIsFull(loopqueue_t* h)
{
   
    return (h->rear + 1) % (N + 1) == h->front ? 1 : 0;
}
int LoopQueueEnQueue(loopqueue_t* h, datatype data)
{
   
    // 1.判满
    if (LoopQueueIsFull(h)) {
   
        printf("队列是满的，入队失败\n");
        return -1;
    }
    // 2.入队
    h->data[h->rear] = data;
    h->rear = (h->rear + 1) % (N + 1);
    return 0;
}
int LoopQueueIsEmpty(loopqueue_t* h)
{
   
    return h->rear == h->front ? 1 : 0;
}
datatype LoopQueueDeQueue(loopqueue_t* h)
{
   
    datatype data;
    // 1.判空
    if (LoopQueueIsEmpty(h)) {
   
        printf("队列是空的，出队失败\n");
        return -1;
    }
    // 2.出队
    data = h->data[h->front];
    h->data[h->front] = 0;
    h->front = (h->front + 1) % (N + 1);

    return data;
}
void LoopQueueShow(loopqueue_t* h)
{
   
    for(int i=0;i<N+1;i++){
   
        printf("-%d",h->data[i]);