Detalles de implementación del lenguaje C de cola (cola)

---

Prefacio

¿Tiene alguna experiencia en el uso de la computadora? A veces la máquina estará en un estado de sospecha de bloqueo. Parece inútil hacer clic en el mouse. Hacer doble clic en cualquier acceso directo no se mueve. Justo cuando pierdes la paciencia y planeas descansar. De repente se despertó y ejecutó todas las operaciones que acababa de hacer clic en orden. En realidad, esto se debe a que varios programas del sistema operativo deben enviarse a través de un canal y ponerse en cola en orden. Aquí se aplica una estructura de datos para implementar la función de cola primero en entrar, primero en salir que se acaba de mencionar, esta es la cola. Este artículo resume brevemente las colas en el algoritmo solo como referencia. No dude en corregir cualquier error u omisión.

---

1. El concepto y la estructura de las colas

La cola es una mesa lineal especial, la característica especial es que solo permite operaciones de borrado en la parte delantera de la mesa e inserta en la parte posterior de la mesa. El final que realiza la operación de inserción se denomina final del equipo, y el final que realiza la operación de eliminación se denomina jefe del equipo.

Los elementos de datos de la cola también se denominan elementos de cola. Insertar un elemento de la cola en la cola se llama poner en cola y eliminar un elemento de la cola de la cola se llama sacar de la cola. Debido a que la cola solo puede insertarse en un extremo y eliminarse en el otro extremo, solo los elementos que ingresan primero a la cola se pueden eliminar primero de la cola, por lo que la cola también se denomina lista lineal FIFO-primero en entrar, primero en salir. .

En segundo lugar, implemente la cola

1. ¿Qué estructura se recomienda para implementar la cola?

Es conveniente agregar datos a una matriz en un extremo, pero para eliminar datos en el otro extremo, se deben mover los elementos de toda la matriz, lo cual es muy ineficiente. Por tanto, se recomienda utilizar una lista enlazada individualmente para implementar la pila.

2. Diseño de interfaz

El código es el siguiente (ejemplo):

typedef int QDataType;

typedef struct QueueNode
{
    
    
	QDataType _data;		//用来存储数据
	struct QueueNode* _next;//用来指向下一个结构体
}QueueNode;

typedef struct Queue
{
    
    
	QueueNode* _head; //存放整个队列的队头
	QueueNode* _tail; //存放整个队列的队尾
}Queue;

//初始化
void QueueInit(Queue* pq);

//销毁
void QueueDestory(Queue* pq);

//入队
void QueuePush(Queue* pq, QDataType x);

//出队
void QueuePop(Queue* pq);

//访问队首的元素
QDataType QueueFront(Queue* pq);

//访问对尾的元素
QDataType QueueBack(Queue* pq);

//返回1是空，返回0是非空
int QueueEmpty(Queue* pq);

//获取数据的个数
int QueueSize(Queue* pq);

3. Implementación de la interfaz

El código es el siguiente (ejemplo):

//初始化
void QueueInit(Queue* pq)
{
    
    
	assert(pq);					 //判断指针的有效性
	pq->_head = pq->_tail = NULL;//队头和队尾指向空指针
}
//销毁
void QueueDestory(Queue* pq)
{
    
    
	assert(pq);
	QueueNode* cur = pq->_head;
	while (cur)
	{
    
    
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	pq->_head = pq->_tail = NULL;
}
//入队
void QueuePush(Queue* pq, QDataType x)
{
    
    
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));//为新节点申请内存空间
	if (newnode == NULL)//判断内存空间是否申请成功
	{
    
    
		printf("内存不足!\n");
		exit(-1);
	}
	newnode->_data = x;   //新节点储存数据
	newnode->_next = NULL;//新节点的下一个指向NULL，即新节点作为队尾
	if (pq->_head == NULL)//将新节点入队
	{
    
    
		pq->_head = pq->_tail = newnode;
	}
	else
	{
    
    
		pq->_tail->_next = newnode;
		pq->_tail = newnode;
	}
}
//出队
void QueuePop(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_head);
	QueueNode* next = pq->_head->_next;
	free(pq->_head);
	pq->_head = next;
	if (pq->_head == NULL)
	{
    
    
		pq->_tail = NULL;
	}
}
//访问队首的元素
QDataType QueueFront(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_head);
	return pq->_head->_data;
}
//访问队尾的元素
QDataType QueueBack(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_head);
	return pq->_head->_data;
}
//返回1是空，返回0是非空
int QueueEmpty(Queue* pq)
{
    
    
	assert(pq);
	return pq->_head == NULL ? 1 : 0;
}
获取数据的个数
int QueueSize(Queue* pq)
{
    
    
	assert(pq);
	QueueNode* cur = pq->_head;
	int size = 0;
	while (cur)
	{
    
    
		++size;
		cur = cur->_next;
	}
	return size;
}

---

Tres, datos de prueba

Llame a diferentes funciones según las diferentes necesidades: el
código es el siguiente (ejemplo):

void TestQueue()
{
    
    
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	while (!QueueEmpty(&q))
	{
    
    
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	QueueDestory(&q);
}
int main()
{
    
    
	TestQueue();
	return 0;
}

Coloque 1, 2, 3 y 4 en la cola y luego imprima los resultados de la siguiente manera:

para resumir

El papel de la cola:

• Escenarios de primero en entrar, primero en salir, como mantener una secuencia justa y hacer cola para atraer buenas oportunidades
• Travesía primero en anchura.
  Lo anterior es el contenido del que se hablará hoy, este artículo solo presenta brevemente la implementación de la cola. Utilice colas para almacenar datos y preste atención a "primero en entrar, primero en salir", es decir, los datos en la cola más avanzada también son los primeros en salir de la cola. Utilice la estructura de la pila para almacenar datos, preste atención al "primero en entrar, el último en salir", es decir, los datos de la pila más avanzada aparecerán al final, mejoraré las deficiencias. Si desea comprender la pila, puede leer este artículo (Detalles de la implementación del lenguaje C de la pila (pila)) .