¿cola? ¿Es eso lo que entiendes?

, vamos a aprender sobre las colas hoy

Hablando de colas, ¿qué te parece?

Las largas colas en la cafetería siguen siendo las colas cuando el banco maneja negocios...

Todos tienen una característica en común: ¡primero en llegar, primero en ser atendido!

Después de aprender el contenido de hoy, encontrará que la cola en la estructura de datos también es la misma

¡Vamos a enrollarnos! ! !

Catálogo de estudios:

1. El concepto y la estructura de la cola

2. Implementación de la cola

1. El concepto y la estructura de la cola

Queue : una tabla lineal especial que solo permite operaciones de inserción de datos en un extremo y operaciones de eliminación de datos en el otro extremo.La cola tiene un First In First Out (primero en entrar, primero en salir)

Enqueue : el extremo que realiza la operación de inserción se llama la cola de la cola .

Dequeue : el extremo que realiza la operación de eliminación se denomina cabeza de la cola.

Nota: La diferencia entre una cola y una pila

Pila: solo se puede insertar y eliminar desde la parte superior de la pila, satisfaciendo el principio de primero en entrar, último en salir

Cola: Se inserta desde el final de la cola y se elimina desde la cabecera, satisfaciendo el principio de primero en entrar, primero en salir.

2. Implementación de la cola

La cola también se puede implementar en la estructura de una matriz y una lista enlazada. Es mejor usar la estructura de una lista enlazada, porque si se usa la estructura de una matriz, será menos eficiente sacar los datos en la cola. de la matriz

Almacenamiento de matrices:

Resumen: use la estructura de la matriz para almacenar la cola. Al insertar, solo la complejidad del tiempo de inserción de la cola es O (1). Al eliminar, debe mover los elementos detrás de la cabeza hacia adelante, de modo que la complejidad del tiempo sea En).

Almacenamiento de listas enlazadas:

Resumen: Usando la estructura de la lista enlazada individualmente para almacenar la cola, la complejidad de tiempo de la inserción solo requiere la inserción de la cola es O (1), y la complejidad de tiempo de la eliminación solo requiere la eliminación de la cabeza y la complejidad del tiempo es O (n). Se puede ver en la figura anterior que la cola evita perfectamente el problema de que la lista de enlaces únicos necesita encontrar el nodo anterior.

¡Ahora usemos una lista enlazada individualmente para implementar una cola! ! !

①Primero definimos dos tipos de estructuras

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

El primer tipo de estructura QueueNode es el nodo, y el segundo Queue es la cabeza y la cola de la cola.

② Inicializar

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

Al inicializar, apuntamos la cabeza y la cola de la cola a NULL respectivamente

③ Insertar

//队尾入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

④Borrar

//队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	//一个   多个
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

}

⑤ Tomar la iniciativa

//取队头
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}

Primero tenemos que confirmar si hay datos en la cola. Si no hay datos, no se pueden devolver. Si los hay, se pueden devolver.

⑥ Tomar la cola de la cola

//取队尾
QDataType QueueBact(Queue* pq)
{
	assert(pq);
	assert(pq->tail);
	return pq->tail->data;
}

⑦ ¿Cuántos nodos hay en el equipo?

//队中数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

⑧ Vacío

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

Use el tipo bool para un juicio vacío, el tipo bool es verdadero y falso

⑨ Destrucción

//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

El beneficio de destruir es: prevenir el problema de las fugas de memoria.

Eso es todo por este problema

¡Los comentarios son bienvenidos a continuación! ! !