Cola en lenguaje C (cola secuencial y cola en cadena) -concepto y operación básica

Prefacio

Ha pasado mucho tiempo desde que actualicé y dije que publicaría los resultados hasta ahora. Una vez finalizado el chisme, el contenido se inicia oficialmente.
Cola, como sugiere el nombre, también es una estructura extremadamente importante en una tabla lineal.
La diferencia con la pila es que la pila inserta y elimina elementos en un extremo, mientras que la cola, elimina del encabezado de la cola, inserta al final de la cola, al igual que la cola en la vida diaria, es aún más vívida .
Este artículo presentará brevemente el concepto y las funciones operativas de las colas y explicará algunos algoritmos básicos de las colas secuenciales (usando matrices) y las colas encadenadas (usando listas enlazadas).

1. Conceptos relacionados de colas

1. Cola y su funcionamiento (primero en entrar, primero en salir)

1.1 Conceptos relacionados

(1) Cola: Solo se permite eliminar elementos en un extremo de la tabla y una tabla lineal con elementos insertados en el otro extremo
(2) Cola vacía: una cola sin elementos
(3) Cabecera de la cola: Solo una final de la cola donde se permite eliminar elementos, también conocido como head, front
(4) Fin de la cola: solo un extremo de la cola puede insertar elementos, también conocido como trasero, cola
(5) Enqueue (enter la cola): inserta un nuevo elemento al final de la
cola (6) Dequeue: elimina uno de la cola Elemento, es decir, elimina el elemento que encabeza el
equipo.

1.2 La operación básica de la cola
(1) InitQueue (q): inicializar, poner q en una cola vacía
(2) QueueEmpty (q): determinar si q es una cola vacía
(3) EnQueue (q, e): insertar e en la cola q tail end
(4) DeQueue (q, e ): eliminación del primer elemento de la cola q, asignado a E
(. 5) GetHead (q, E); primera lectura de elementos de la cola, asignado a E
(. 6) QueueClear (q): establece q en cola vacía

Dos, la operación básica de la cola en cadena

1. Cola encadenada: una cola que utiliza una estructura encadenada para el almacenamiento, generalmente representada por una lista enlazada individualmente con un nodo de encabezado.

Para mejorar la eficiencia de la inserción y eliminación, se establecen dos punteros en el puntero de la cabeza.
Formas generales:
(1) Q.front: el primer puntero del equipo, apuntando al nodo de la cabeza
(2) Q.rear: el último puntero del equipo, apuntando al final del equipo.
Nota: Cuando la cola está vacía, (1) (2) se ejecutan en el nodo principal
(3) Q.front-> data: no poner elementos
(4 ) Q.fornt-> siguiente: apunte al primer nodo a1

2. Defina el tipo de nodo

(1) El tipo de nodo que almacena el elemento: campo de datos y campo de puntero

//定义结点类型
typedef struct Qnode
{
    
    
	ElemType data;//其中数据域data为抽象元素类型
	struct Qnode *next;//其中next为指针类型 
}Qnode,*QueuePtr;//其中，Qnode为结点类型， QueuePtr：指向Qnode的指针类型

(2) Tipo de nodo compuesto por punteros de cabeza y cola

//由头、尾指针组成的结点类型
typedef struct
{
    
    
	Qnode *front;//头指针
	Qnode *rear;//尾指针 
}LinkQueue;//链式队列类型 

(3) Generar algoritmo de cola vacía: inicializar la cola

//生成空队列算法：初始化队列	
#define LENG sizeof(Qnode)//求结点所占的单元数
LinkQueue InitQueue()//生成仅带表头结点的空队列Q
{
    
    
	LinkQueue Q;//说明变量Q
	Q.front = Q.rear = (QueuePtr)malloc(LENG);//生成表头结点
	Q.front->next = NULL;//表头结点的next为空指针
	return Q;//返回Q的值 
} 

(4) Inserte un nuevo elemento x cuando la cola esté (no) vacía

//（非）空队列时插入新元素x	
LinkQueue Enqueue(LinkQueue Q,ElemType e)
{
    
    
	Qnode *p;//说明变量p
	p = (Qnode*)malloc(LENG);//生成新元素结点
	p->data = e;//装入元素e
	p->next = NULL;//为队尾结点
	Q.rear->next = p;//插入新结点
	Q.rear = p;//修改尾指针
	return Q;//返回Q的新值 
} 

3. Eliminación de elementos (cambiar el nodo de encabezado)

Nota: Si la cola original tiene solo un nodo, también debe considerar el
algoritmo de eliminación de cola de la cola de la cadena del puntero de cola.

//链式队列的出队算法	
LinkQueue DelQueue(LinkQueue Q,ElemType *e)
{
    
    
	Qnode *p;//声明变量p
	if (Q.front==Q.rear)//若原队列为空
	{
    
    
		printf ("Empty queue");//空队列
		return Q; 
	}
	p = Q.front->next;//p指向要删除的队头结点
	(*e) = p->data;//取出元素
	Q.front->next = p->next;//删除队头结点
	if (Q.rear==p)//若原队列只有1个结点
	{
    
    
		Q.rear = Q.front;//修改尾指针 
	}
	free(p);//释放被删除的空间
	return Q;//返回出队后的Q 
}

Tres, el funcionamiento básico de la cola secuencial

1. Colas secuenciales y "desbordamiento falso"

Supongamos que se utiliza una matriz unidimensional Q [0… 5] para representar la cola secuencial.
Sea f apunte al elemento de cabecera yr apunte a una celda vacía después del elemento de cola.
(1) Después de la inicialización: cola vacía r = f
(2) Después de que el elemento ABC ingresa a la cola: f Apunta a A, r apunta a la siguiente unidad después de C (es decir, Q [3])
(3) Después de que ABC abandona la cola: f se mueve a r, luego la cola vacía f = r
(4) Después de que DEF ingresa a la cola, r se mueve detrás de F (Q [5]) después de
(5) si G quiere ingresar en este momento, se juzgará como un desbordamiento falso,
pero en este momento Q [0], Q [1], etc. todavía están vacíos

2. Método uno para resolver el falso desbordamiento: mover el elemento

(6) Después de que DEF se mueve al frente, ocupa Q [0], Q [1] y Q [2]. En este momento, fr también se mueve.
(7) Después de que G ingresa al equipo, r apunta a Q [3]
. Desventajas de este método: más tiempo, los elementos móviles son caros

3. Método 2: use Q como una tabla circular (cola circular)

Es decir, en (4), r apuntará nuevamente a Q [0].
En (5), G se colocará en Q [0] cuando G quiera ingresar al equipo, y r se moverá hacia atrás para apuntar a Q [ 1]
(6) En este momento, HI Después de ingresar a la cola, la cola está llena y f = r
causa un problema. Cuando f = r, la cola está vacía o llena (ambigüedad)

(1) Solución de ambigüedad

Opción 1: Agregar una variable de identificación.
Opción 2: Reservar la última unidad y no usarla, es decir, probar antes de ingresar a la cola.
Si r + 1 == f, indica que queda la última unidad, y la cola
se considera que está lleno en este momento. Es decir, si la cola es Q [0 ... maxleng-1], un total de maxleng-1 elementos

(2) La condición de cola completa de la cola circular
Cuando r + 1f o (f0) && (rmaxleng-1) ， 即 ： (r + 1)% maxlengf es cola llena, la
condición de cola vacía sigue siendo r == f

4. Ejemplos de algoritmos de cola secuencial

(1) Defina el tipo C de la cola

//顺序队列算法举例：定义队列的C类型
#define MAXLENG 100
typedef struct
{
    
    
	ElemType elem[MAXLENG];
	int front,rear;//分别指向队首结点和队尾结点后的下一个单元 
}SeQueue;
SeQueue Q;//定义结构变量Q表示队列 

(2) Algoritmo de puesta en cola En_Queue

//假设用Q表示顺序队列，e为进队元素
int En_Queue (SeQueue &Q,ElenType e)
{
	if ((Q.rear+1)%MAXLENG==Q.front)//若Q已满，退出
		return ERROR;
	Q.elem[Q.rear] = e;//装入新元素e
	Q.rear++;//尾指针后移一个位置
	Q.rear = Q.rear%MAXLENG;//为循环队列
	return OK; 
} 
在这里插入代码片

(3) Algoritmo Dequeue De_Queue

//出队算法De_Queue
int De_Queue
{
    
    
	if (Q.front==Q.rear)//Q为空队列，退出
		return ERROR;
	e = Q.elem[Q.front];//取走队头元素，赋值给e
	Q.front = (Q.front+1)%MAXLENG;//循环后移到一个位置
	return OK; 
 } 
 

para resumir

En general, la determinación de colas vacías y llenas es mucho más complicada que la de la pila y pueden producirse desbordamientos falsos. Debido a que se elimina al principio de la línea, se necesita más tiempo para resolver el problema moviendo elementos. Por tanto, la cola en cadena tiene sus ventajas. El requisito de la computadora también es menor que el de la matriz y no se requiere espacio continuo. Cuando se almacenan muchos datos, se pueden utilizar colas en cadena.
ps: el código no es original.
Si hay algún error, corrígeme.
El próximo artículo presentará algunas operaciones matriciales especiales.