Continuando con el artículo anterior, hemos aprendido el contenido de conocimiento relevante de la pila. A continuación, conozcamos otra tabla lineal especial, la cola, que es similar a la pila. El propósito de este artículo es comprender y comprender el concepto de la cola, y darse cuenta de la cola circular
Tabla de contenido
En segundo lugar, realiza la cola circular.
1. Formato de estructura e inicialización
2. Insertar elementos al final de la cola (en la cola)
3. Eliminación de datos al principio de la cola (fuera de la cola)
3. Implementación completa del código
1. Conoce la cola
1. El concepto de cola
Cola: una tabla lineal especial que solo permite insertar datos en un extremo y eliminar datos en el otro extremo. La cola tiene las características de primero en entrar, primero en salir. Insertar datos al final de la cola se llama ingresar a la cola, y la eliminación de datos al principio de la cola se denomina Para eliminar la cola.
como muestra la imagen:
2. Implementación de la cola
Las colas se pueden implementar de dos maneras, que se pueden implementar mediante listas secuenciales y listas enlazadas, respectivamente. Las colas se dividen en colas circulares y colas no circulares.
distinguir:
1. Para una cola no circular, es mejor usar la estructura de la lista enlazada, porque si se usa la estructura de la matriz, la eficiencia será menor cuando los datos salgan al principio de la matriz.
2. Cuando se usa una cola circular, es más conveniente y conciso usar una matriz. La única desventaja es que cuando se usa una matriz para una cola circular, solo puede ser una matriz estática. No se puede formar una cola circular dinámica. De Por supuesto, se puede utilizar una lista enlazada circular.
En segundo lugar, realiza la cola circular.
Usamos la estructura de la matriz para implementar la cola circular
1. Formato de estructura e inicialización
el código se muestra a continuación:
#define MAXSIZE 11//表示的是数组的元素个数，多一个1，是为了留给rear空间的
typedef struct SqQueue {
int data[MAXSIZE];
int front;//队头
int rear;//队尾 front 和 rear 就是指针（类似）
}SqQueue;
//初始化队列
void InitQueue(SqQueue* ps) {
//初始化队列只需要队头队尾都为0 表示下标起始位置
ps->front = ps->rear = 0;
}De hecho, estamos usando una matriz estática, y solo de esta manera podemos realizar la cola circular.Si es una matriz dinámica, el efecto circular no se puede lograr, y el tamaño MAXSIZE definido es 11, y hay un espacio que no almacena valores Como signo.
2. Insertar elementos al final de la cola (en la cola)
El punto más importante es entender
(posterior+1)%MAXSIZE==frente Esta es la bandera para juzgar si la cola está llena
como muestra la imagen:
el código se muestra a continuación:
//队尾插入元素
void EnQueue(SqQueue* ps,int data) {
//插入的时候先进行判满
if ((ps->rear + 1) % MAXSIZE == ps->front) {//最多存储MAXSIZE-1个元素
//表示已经满了
perror("队列已经满了，无法加入新元素\n");
exit(-1);//stdlib.h 头文件里面的
}
ps->data[ps->rear] = data;
ps->rear = (ps->rear + 1) % MAXSIZE;
}3. Eliminación de datos al principio de la cola (fuera de la cola)
como muestra la imagen:
el código se muestra a continuación:
//队头出队
//只需要移动指针位置即可
void OutQueue(SqQueue* ps, int* data) {
//出队先判别是否为空
if (ps->rear == ps->front) {
perror("为空队列，无法出队\n");
exit(-1);
}
*data = ps->data[ps->front];
ps->front = (ps->front + 1) % MAXSIZE;
//不需要整体移动只要将队头指针后移就可以
}4. imprimir
como muestra la imagen:
el código se muestra a continuación:
//遍历打印元素
void PrintQueue(SqQueue* ps) {
int i = 0;
printf("Queue->");
while ((i + ps->front)%MAXSIZE != ps->rear) {
//从front的队头位置开始，i从0开始 ++一直到等于rear结束
printf("%d->", ps->data[i + ps->front]);
i = (i + 1) % MAXSIZE;
}
printf("NULL\n");
}5. Borre la cola, devuelva el elemento al principio de la cola y devuelva la cantidad de elementos en la cola.
el código se muestra a continuación:
//将队列清空
void ClearQueue(SqQueue* ps) {
ps->front = ps->rear = 0;
}
//返回队头元素
void GetHead(SqQueue* ps, int* data) {
if (ps->front == ps->rear) {
perror("为空队列\n");
exit(-1);
}
*data = ps->data[ps->front];
}
//返回队列中的元素个数
int CountSqQueue(SqQueue* ps) {
return (ps->rear - ps->front + MAXSIZE) % MAXSIZE;
}3. Implementación completa del código
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<stdlib.h>
//构建的是循环队列，是使用数组的形式，完成的循环队列
#define MAXSIZE 11//表示的是数组的元素个数，多一个1，是为了留给rear空间的
typedef struct SqQueue {
int data[MAXSIZE];
int front;//队头
int rear;//队尾 front 和 rear 就是指针（类似）
}SqQueue;
//初始化队列
void InitQueue(SqQueue* ps) {
//初始化队列只需要队头队尾都为0 表示下标起始位置
ps->front = ps->rear = 0;
}
//将队列清空
void ClearQueue(SqQueue* ps) {
ps->front = ps->rear = 0;
}
//队尾插入元素
void EnQueue(SqQueue* ps,int data) {
//插入的时候先进行判满
if ((ps->rear + 1) % MAXSIZE == ps->front) {//最多存储MAXSIZE-1个元素
//表示已经满了
perror("队列已经满了，无法加入新元素\n");
exit(-1);//stdlib.h 头文件里面的
}
ps->data[ps->rear] = data;
ps->rear = (ps->rear + 1) % MAXSIZE;
}
//队头出队
//只需要移动指针位置即可
void OutQueue(SqQueue* ps, int* data) {
//出队先判别是否为空
if (ps->rear == ps->front) {
perror("为空队列，无法出队\n");
exit(-1);
}
*data = ps->data[ps->front];
ps->front = (ps->front + 1) % MAXSIZE;
//不需要整体移动只要将队头指针后移就可以
}
//遍历打印元素
void PrintQueue(SqQueue* ps) {
int i = 0;
printf("Queue->");
while ((i + ps->front)%MAXSIZE != ps->rear) {
//从front的队头位置开始，i从0开始 ++一直到等于rear结束
printf("%d->", ps->data[i + ps->front]);
i = (i + 1) % MAXSIZE;
}
printf("NULL\n");
}
//返回队头元素
void GetHead(SqQueue* ps, int* data) {
if (ps->front == ps->rear) {
perror("为空队列\n");
exit(-1);
}
*data = ps->data[ps->front];
}
//返回队列中的元素个数
int CountSqQueue(SqQueue* ps) {
return (ps->rear - ps->front + MAXSIZE) % MAXSIZE;
}
int main() {
SqQueue Q;
InitQueue(&Q);
EnQueue(&Q, 1);
EnQueue(&Q, 2);
EnQueue(&Q, 3);
EnQueue(&Q, 4);
EnQueue(&Q, 5);
PrintQueue(&Q);
int a = 0;
OutQueue(&Q, &a);
PrintQueue(&Q);
EnQueue(&Q, 1);
EnQueue(&Q, 2);
//EnQueue(&Q, 3);
EnQueue(&Q, 4);
EnQueue(&Q, 4);
EnQueue(&Q, 5);
EnQueue(&Q, 5);
PrintQueue(&Q);
}
Resumir
Este artículo comprende el nuevo concepto de colas. También implementamos colas circulares a través de la estructura de matrices. Esta forma de implementar colas circulares es relativamente simple y fácil de entender. Lo principal es entender por qué MAXSIZE necesita un espacio adicional, por ejemplo, ajústelo a 11. Hay juicios vacíos, juicios completos y operaciones. Esto es lo más importante.
Juicio vacío: trasero == delantero
Juicio completo: (trasero+1)%MAXSIZE==delantero
Obtener el número de elementos de la cola: (trasero-delantero+MAXSIZE)%MAXSIZE
El método para obtener la siguiente posición de la parte delantera, trasera e i:
Por ejemplo: trasero=(trasero+1)%MAXSIZE