Hay un código de implementación completo al final de este artículo, que no es fácil de escribir. Adjunte un enlace a este artículo para reimprimirlo.
contenido
Primero, el concepto de cola en cadena.
En segundo lugar, el funcionamiento básico de la cola en cadena.
(1) Inicialización del equipo de la cadena
(2), determine si el equipo de la cadena está vacío
(3), encuentre la longitud de la cola de la cadena
(5), encuentra el primer elemento del equipo de la cadena
(6), operación de eliminación de cola
Primero, el concepto de cola en cadena.
¿Qué es una cola encadenada? Cuando se piensa en una cola encadenada, todo el mundo debe pensar en el funcionamiento básico de una lista de enlace simple en una tabla de secuencia. Comparemos: una lista de enlace simple usa un puntero de cabeza o un puntero de cola para implementar el elemento inserción y eliminación, etc., es decir, el método de inserción de la cabeza y la inserción de la cola. En cuanto a la cola encadenada, todos sabemos que la cola es una cola que se elimina al principio de la cola y luego se ingresa al final de la cola, en lugar de completar la tarea en un segmento, por lo que necesitamos dos punteros para señalar al principio y al final de la cola, respectivamente. Los dos realizan sus respectivas funciones. Cuando se va a realizar la operación de eliminación de la cola, el delantero del puntero de la cabeza tiene la última palabra, y cuando se va a realizar la operación de puesta en la cola, la cola El puntero trasero tiene la última palabra.
Restricciones: apuntamos el puntero principal a la posición anterior del primer elemento en la cola, no hay nada en él, es solo una marca, marcarlo apunta a una cola, a través de la cual se puede encontrar la cola, como un solo lista enlazada Inserción del encabezado; mientras que el puntero de la cola apunta al último elemento de la cola.
En segundo lugar, el funcionamiento básico de la cola en cadena.
Después de familiarizarnos con el concepto de cola encadenada, podemos definir la operación básica de la cola encadenada. La operación no se limita a lo que dije. De acuerdo con la situación real, defina la operación requerida.
(1) Inicialización del equipo de la cadena
(2), determine si el equipo de la cadena está vacío
(3), encuentre la longitud de la cola de la cadena
(4) Operación de cola
(5), operación de eliminación de cola
(6), encuentre el primer elemento del equipo de la cadena, (también podemos encontrar el elemento de cola del equipo de la cadena)
Tres, los pasos de implementación específicos de la operación básica.
Primero declare una estructura de nodo de cola, que incluye el campo de puntero siguiente y los datos del campo de datos de este nodo. A continuación, declare una estructura de cola, incluido el puntero de la cabeza en la parte delantera y el puntero de la cola en la parte trasera de la cola.
#include <stdio.h>
#include <stdlib.h>
typedef int Elemtype;
//声明一个结构体来表示节点
typedef struct Node
{
Elemtype data; //节点数据域
struct Node * next; //节点指针域
}QueueNode;
//声明一个结构体来定义上面这个结构体的两个指针
typedef struct
{
QueueNode *front,*rear;//分别指向队首和队尾的指针
}LinkQueue;(1) Inicialización del equipo de la cadena
El equipo de cadena actual es un equipo vacío, por lo que el puntero de cabeza, el puntero de cola y el puntero de nodo apuntan al mismo lugar y apuntan a nulo.
//首先进行初始化
void Init(LinkQueue *s)
{
QueueNode * p;
p=(QueueNode*)malloc(sizeof(QueueNode));//为指向节点的指针分配空间
p->next=NULL;
s->front=s->rear=p;
}(2), determine si el equipo de la cadena está vacío
Debido a que el puntero de la cabeza y el puntero de la cola que definimos en el momento de la inicialización apuntan a la misma ubicación marcada como nula, entonces juzgamos si apuntan al mismo lugar.
//判断队列是否为空,为空返回真1，不为空返回假0
int Empty(LinkQueue s)
{
//队空的条件是头指针和尾指针指向相同的地方
if(s.front==s.rear)
{
return 1;
}
return 0;
}(3), encuentre la longitud de la cola de la cadena
Declaramos una variable puntero de tipo de nodo temporal p, dejamos que apunte al primer nodo de la cadena, declaramos una variable para registrar la longitud, cuando el nodo al que apunta p no está vacío, aumentamos la longitud en uno, y al final Al mismo tiempo, el puntero p también se mueve hacia atrás una posición.
//求队列长度
int GetLength(LinkQueue s)
{
//声明一个节点类型的指针
QueueNode *p;
//让p指向队列的头指针
p=s.front;
//声明一个变量用来记录队列当前长度
int length=0;
while(p->next)//当指针p所指的节点不为空时执行循环体
{
length++;
p=p->next;
}
return length;//返回当前队列的长度
}(4) Operación de cola
Como dijimos al principio del artículo, la operación de puesta en cola está determinada por el puntero posterior de la cola. Declaramos una variable de puntero p de tipo nodo, le asignamos espacio, luego le asignamos el elemento que se va a poner en cola, luego apuntamos el puntero trasero a este nodo y luego movemos el puntero trasero un bit. Esto es muy similar al funcionamiento del método de inserción de la cola de la lista enlazada secuencial, puedes compararlo y la idea es la misma.
//入队操作
void Add(LinkQueue *s,Elemtype x)
{
//声明一个节点类型的指针变量用来存储要入队的元素
QueueNode *p;
p=(QueueNode*)malloc(sizeof(QueueNode));
if(!p){
printf("内存分配失败\n\n");
return;
}
p->data=x; //指针指向的节点的数据域存放x
p->next=NULL; //指针指向的节点的指针域置为空
s->rear->next=p; //将队列的尾指针的指针域next指向指针p所指的节点
s->rear=p; //将队列的尾指针向后移一位，指向刚入队的节点的位置
}(5), encuentra el primer elemento del equipo de la cadena
Aquí solo pedimos el elemento de la cabeza, no el elemento de la cola. Al buscar el elemento principal de la cola, debemos determinar si la cola es una cola vacía. Si no está vacío, realizaremos la operación de buscar el primer elemento de la cola. Devuelve directamente el valor del primer elemento al que apunta el frente del puntero de la cabeza.
//获取队首元素
Elemtype GetTop(LinkQueue s)
{
//首先判断队列是否为空
if(Empty(s))
{
printf("队列为空，无法获取队首元素\n\n");
return 0;
}
return s.front->next->data;//不为空的话就返回队首指针指向的第一个元素的数据域
}(6), operación de eliminación de cola
La operación de eliminación de la cola está determinada por el frente del puntero de la cabeza del equipo. Necesitamos determinar si la cola está vacía. Declaramos una variable de puntero p de tipo nodo y la apuntamos a la posición del primer nodo del elemento principal de la cola. Luego, permita que e registre el valor del elemento actualmente fuera de la cola. Apunte el puntero principal al siguiente nodo del primer nodo. Esto es muy similar a la operación de eliminación del método de inserción de encabezados de la lista enlazada secuencial. Recuerde liberar el puntero al nodo fuera de la cola.
//出队操作
void Del(LinkQueue *s,Elemtype *e)
{
//先判断队列是否为空
if(Empty(*s))
{
printf("当前队列为空，无法执行出队操作\n\n");
return;
}
//用临时变量保存出队的元素
QueueNode *p;
p=s->front->next;
if(p==s->rear) //如果p指向了队尾节点
{
s->front=s->rear; //那么删除之后队首指针和尾指针指向同一个位置
}
*e=p->data;
s->front->next=p->next;//将队首指针指向第一个节点的下一个节点。
free(p);
}(7), la función principal
int main()
{
//声明一个节点类型的变量
Elemtype e;
//声明一个顺序队名字为s
LinkQueue s;
//对这个顺序队进行初始化
Init(&s);
printf("==============================================================\n");
printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
printf("当前队列的长度为：%d\n\n",GetLength(s));
//执行入队操作
Add(&s,5);
Add(&s,4);
Add(&s,6);
Add(&s,2);
printf("==============================================================\n");
printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
printf("当前队列的长度为：%d\n\n",GetLength(s));
//获取当前队首元素
printf("==============================================================\n");
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
//执行出队操作
printf("==============================================================\n");
Del(&s,&e);
printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
//获取当前队首元素
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
//再执行一次出队操作
printf("==============================================================\n");
Del(&s,&e);
printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
//获取当前队首元素
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
//再执行一次出队操作
printf("==============================================================\n");
Del(&s,&e);
printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
//获取当前队首元素
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
return 0;
}(8), ejecución de resultados
(9), código completo
#include <stdio.h>
#include <stdlib.h>
typedef int Elemtype;
//声明一个结构体来表示节点
typedef struct Node
{
Elemtype data; //节点数据域
struct Node * next; //节点指针域
}QueueNode;
//声明一个结构体来定义上面这个结构体的两个指针
typedef struct
{
QueueNode *front,*rear;//分别指向队首和队尾的指针
}LinkQueue;
//首先进行初始化
void Init(LinkQueue *s)
{
QueueNode * p;
p=(QueueNode*)malloc(sizeof(QueueNode));
p->next=NULL;
s->front=s->rear=p;
}
//判断队列是否为空,为空返回真1，不为空返回假0
int Empty(LinkQueue s)
{
//队空的条件是头指针和尾指针指向相同的地方
if(s.front==s.rear)
{
return 1;
}
return 0;
}
//求队列长度
int GetLength(LinkQueue s)
{
//声明一个节点类型的指针
QueueNode *p;
//让p指向队列的头指针
p=s.front;
//声明一个变量用来记录队列当前长度
int length=0;
while(p->next)//当指针p所指的节点不为空时执行循环体
{
length++;
p=p->next;
}
return length;//返回当前队列的长度
}
//入队操作
void Add(LinkQueue *s,Elemtype x)
{
//声明一个节点类型的指针变量用来存储要入队的元素
QueueNode *p;
p=(QueueNode*)malloc(sizeof(QueueNode));
if(!p){
printf("内存分配失败\n\n");
return;
}
p->data=x; //指针指向的节点的数据域存放x
p->next=NULL; //指针指向的节点的指针域置为空
s->rear->next=p; //将队列的尾指针的指针域next指向指针p所指的节点
s->rear=p; //将队列的尾指针向后移一位，指向刚入队的节点的位置
}
//获取队首元素
Elemtype GetTop(LinkQueue s)
{
//首先判断队列是否为空
if(Empty(s))
{
printf("队列为空，无法获取队首元素\n\n");
return 0;
}
return s.front->next->data;//不为空的话就返回队首指针指向的第一个元素的数据域
}
//出队操作
void Del(LinkQueue *s,Elemtype *e)
{
//先判断队列是否为空
if(Empty(*s))
{
printf("当前队列为空，无法执行出队操作\n\n");
return;
}
//用临时变量保存出队的元素
QueueNode *p;
p=s->front->next;
if(p==s->rear)
{
s->front=s->rear;
}
*e=p->data;
s->front->next=p->next;
free(p);
}
int main()
{
//声明一个节点类型的变量
Elemtype e;
//声明一个顺序队名字为s
LinkQueue s;
//对这个顺序队进行初始化
Init(&s);
printf("==============================================================\n");
printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
printf("当前队列的长度为：%d\n\n",GetLength(s));
//执行入队操作
Add(&s,5);
Add(&s,4);
Add(&s,6);
Add(&s,2);
printf("==============================================================\n");
printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
printf("当前队列的长度为：%d\n\n",GetLength(s));
//获取当前队首元素
printf("==============================================================\n");
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
//执行出队操作
printf("==============================================================\n");
Del(&s,&e);
printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
//获取当前队首元素
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
//再执行一次出队操作
printf("==============================================================\n");
Del(&s,&e);
printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
//获取当前队首元素
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
//再执行一次出队操作
printf("==============================================================\n");
Del(&s,&e);
printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
//获取当前队首元素
e=GetTop(s);
if(e){
printf("当前队列的队首元素为：%d\n\n",e);
}
return 0;
}
Resumen: aprenda a comparar la tabla de secuencia, la pila y el equipo aquí. Hay muchas similitudes, y cada una tiene su propia singularidad. Combinado con mis artículos anteriores sobre la estructura de datos, puede compararlo usted mismo.
Respete los resultados del trabajo e indique el enlace original y la fuente para la reimpresión.