come from C Language version data structure ： Introduce the establishment of circular queue , The team , Out of the team , Please, captain , Take the team head element operation .

---

Circular queue

A sequential storage of queues , Why is it called circular queue ？ First of all ： prevent " False spillover ", This is caused by the operation of the team " The team is at the end of the line , Team leader ". There's probably room elsewhere , But it's wrong （ Transboundary ） Specific measures ： The book is about using a mold to run （%） Resolved , When a ring appears , They don't show up " False spillover " The situation of

---

Tips ： The following is the main body of this article , The following cases can be used for reference

One 、 use CLion The feeling of writing code

CLion Is based on C/C++ A tool of , Xiaobian compiled this article by using this , Personal feeling ： senior , so much trouble , But it has complete functions , such as ： You introduce a library , But you didn't use the function in it , It will turn gray , Without color , More rigorous , It reminds you , Don't waste memory , Occupancy resources .

Two 、 Basic operations of queues

1. Build and initialize

The code is as follows （ Example ）：

//  Build queue 
typedef struct Queue{
    
    char sa[MAX];                // Store the data 
    int rear;                    // Tail pointer 
    int front;                   // Header pointer 
}SQueue;

// Initialize queue 
SQueue *initQueue()
{
    
    SQueue *Q;
    Q = (struct Queue*)malloc(sizeof(struct Queue));	// Apply for memory space 
    Q->front = 0;
    Q->rear = 0;
    return Q;		// Returns the initialized queue 
}

 The core of initialization and establishment ：  The tail and head of the team point to 0 and  To apply for space 

---

2. The team

// The team 
void push(SQueue *p, char x)
{
    	
    if((p->rear + 1) % MAX == p->front)   // Judge the condition of fullness  
    {
    
        printf(" Right full ");
        exit(0);
    }
    p->sa[p->rear] = x;                         // The team is at the end of the line 
    p->rear = (p->rear + 1) % MAX;
    // Using modular operation ,  Prevent false overflow 
}

 The core ： It was originally the tail pointer +1 Can then ,  But to prevent overflow ,  Use modular operation , Form a ring .

---

3. Out of the team

// Out of the team 
char pop(SQueue *p)
{
    
    if(p->rear == p->front)     // Judge the condition of team empty 
    {
    
        printf(" In the air ");
        exit(0);
    }
    char e = p->sa[p->front];		// The element used to store the dequeue 
    p->front = (p->front + 1) % MAX;
    return e;
}
 The core ： Just like joining the team ,  Just judge the condition and return value one more step ,  Head to head , Header pointer +1,
	   Adopt modular operation .

---

4. Take the queue header element and queue length

// Take the length of the circular queue 
int queuelength(SQueue *p)
{
    
    return (p->rear - p->front + MAX) % MAX;
    // effect ： Add an absolute value ,  Remember it 
}

// Take the queue header element of the circular queue 
char GetHead(SQueue *p)
{
    
    if(p->rear == p->front)		// Judge the condition of null 
    {
    
        exit(0);
    }
    char e;
    e = p->sa[p->front];		// Out of the queue ,  Just don't move the tail pointer 
    return e;
}

---

Code implementation

//
// Created by xhh on 2021/6/30.
//
// Basic operation of circular queue 
#include<stdio.h>
#include<stdlib.h>
#define  MAX 5                  // The maximum length of the circular queue 

typedef struct Queue{
    
    char sa[MAX];                // Store the data 
    int rear;                    // Pointer to a party 
    int front;                   // Team head pointer 
}SQueue;

// Create a queue 
SQueue *initQueue()
{
    
    SQueue *Q;
    Q = (struct Queue*)malloc(sizeof(struct Queue));
    Q->front = 0;
    Q->rear = 0;
    return Q;
}

// The team 
void push(SQueue *p, char x)
{
    
    if((p->rear + 1) % MAX == p->front)// Using modular operation ,  Prevent false overflow 
    {
    
        printf(" Right full ");
        exit(0);
    }
    p->sa[p->rear] = x;                         // The team is at the end of the line 
    p->rear = (p->rear + 1) % MAX;
}

// Out of the team 
char pop(SQueue *p)
{
    
    if(p->rear == p->front)
    {
    
        printf(" In the air ");
        exit(0);
    }
    char e = p->sa[p->front];
    p->front = (p->front + 1) % MAX;
    return e;
}

// Take the length of the circular queue 
int queuelength(SQueue *p)
{
    
    return (p->rear - p->front + MAX) % MAX;
}

// Take the queue header element of the circular queue 
char GetHead(SQueue *p)
{
    
    if(p->rear == p->front)
    {
    
        exit(0);
    }
    char e;
    e = p->sa[p->front];
    return e;
}

// Print function 
void display(SQueue *p)
{
    
    int index = p->front;            // Team head pointer 
    while(p->rear != index)
    {
    
     printf("%c->", p->sa[index]);
     index = (index + 1) % MAX;
    }
}

int main()
{
    
    SQueue *A;   // Create a queue 
    A = initQueue();            // initialization 
    printf(" The team ：");
    for(char i = 'A'; i <= 'D'; i++)
    {
    
        push(A, i);   // The team 
    }
    display(A);
    printf("\n captain ：%d\n", queuelength(A));
    printf(" Head element ：%c\n", GetHead(A));
    printf(" Out of the team ：");
    for(int i = 0; i < 4; i++)
    {
    
        printf("%c->", pop(A));
    }
    system("pause");
    return 0;
}

 result ：
 The team ：A->B->C->D->
 captain ：4
 Head element ：A
 Out of the team ：A->B->C->D->

Recommendation of compiling tools ： Xiaobai studies C Language , I still recommend VS, Simple and convenient operation .
Circular queue ： It's actually a sequential storage structure , Adopt modular operation , It realizes the connection of head and tail , It's essentially an array , It just changed the operation of moving the pointer , Or in the form of an array .