Estructuras de datos: pilas y colas (súper detallado)

Tabla de contenido

editar

pila:

El concepto y la estructura de la pila:

 Implementación de la pila:

cola:

El concepto y la estructura de la cola:

 Implementación de la cola:

Conocimiento extendido:

 Lo anterior es mi opinión personal y mi análisis del aprendizaje de tablas lineales. ¡Bienvenidos todos a discutir en el área de comentarios!

¡Gracias por los chicos de tres conexiones con un solo clic! ¡Gracias por los chicos de tres conexiones con un solo clic! ¡Gracias por los chicos de tres conexiones con un solo clic!

---

pila:

El concepto y la estructura de la pila:

        Pila: una lista lineal especial que solo permite la inserción y eliminación de elementos en un extremo fijo . El extremo donde se realizan las operaciones de inserción y eliminación de datos se denomina parte superior de la pila y el otro extremo se denomina parte inferior de la pila . Los elementos de datos en la pila siguen el principio de LIFO (Last In First Out). Generalmente se usa en 1. Cola de equidad (máquina de dibujo de números) 2. BFS (recorrido primero en amplitud).

Push stack: la operación de inserción de la pila se llama push/push/push, y los datos entrantes se encuentran en la parte superior de la pila.

Popping: La operación de eliminación de la pila se llama popping. Los datos de salida también están en la parte superior de la pila.

 Implementación de la pila:

        La implementación de la pila generalmente se puede implementar utilizando una matriz o una lista enlazada.Relativamente hablando , la estructura de la matriz es mejor . Porque el costo de insertar datos al final de la matriz es relativamente pequeño . La inserción de la cola de la cadena necesita movilizar más datos , y hay más consumo en el proceso .

// Admite pila de crecimiento dinámico

typedef int STDataType ;

Pila de estructura typedef

{

STDataType * _a ;

int _top ; // Parte superior de la pila

int_capacidad ; // capacidad _

} Pila ;

// Inicializar la pila

void StackInit ( Pila * ps );

// Empuje en la pila

void StackPush ( Stack * ps , datos STDataType );

// emerger

anular StackPop ( Pila * ps );

// Obtener el elemento superior de la pila

STDataType StackTop ( Pila * ps );

// Obtener el número de elementos válidos en la pila

int StackSize ( Pila * ps );

// Comprueba si la pila está vacía, devuelve un resultado distinto de cero si está vacío, devuelve 0 si no está vacío

int StackEmpty ( Pila * ps );

// Destruir la pila

anular StackDestroy ( Stack * ps );

 //Inicializar la pila

---

//初始化
void SLInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

//Pulse en la pila

//入栈
void SLPush(SL* ps, STDataType x)
{
	assert(ps);
	//栈顶=容量说明需要扩容
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
	ps->a[ps->top] = x;
	//后缀++方便下一次入栈和打印栈顶
	ps->top++;
}

// emerger

//出栈
void SLPop(SL* ps)
{
	assert(ps);
	//为空情况“0”
	assert(ps->top > 0);
	//
	--ps->top;
}

//Obtener el elemento superior de la pila

//获得栈顶元素
STDataType SLTTop(SL* ps)
{
	assert(ps);
	//为空情况“0”
	assert(ps->top > 0);
	int n = (ps->top) - 1;
	return ps->a[n];
}

 // Obtener el número de elementos válidos en la pila

//获取栈中有效元素个数
int SLSize(SL* ps)
{
	assert(ps);
	return ps->top;
}

//Destruye la pila

//销毁栈
void SLDestroy(SL* ps)
{
	assert(ps);
	//开辟数组优势：一次全部释放
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

// Comprobar si la pila está vacía, devolver un resultado distinto de cero si está vacío y devolver 0 si no está vacío

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool SLEmpty(SL* ps)
{
	assert(ps);
	//为“0”说明为NULL
	if (ps->top == 0)
	{
		return true;
	}
	return false;
}

cola:

El concepto y la estructura de la cola:

         Queue: Una tabla lineal especial que solo permite insertar datos en un extremo y eliminar datos en el otro extremo.La cola tiene FIFO (primero en entrar, primero en salir).

En la cola: el final de la operación de inserción se llama la cola de la cola; 

Fuera de la cola: el final de la operación de eliminación se denomina cabeza de la cola.

 Implementación de la cola:

        Las colas también se pueden implementar en la estructura de arreglos y listas enlazadas . Es mejor usar la estructura de listas enlazadas , porque si usa la estructura de arreglos , la eficiencia de eliminar la cola y generar datos en la cabecera del arreglo será relativamente bajo _

// Estructura de la cadena: representa la cola

typedef struct QListNode

{

estructura QListNode * _pNext ;

QDataType_datos ;

} QNodo ;

// La estructura de la cola

typedef struct Cola

{

QNodo * _frente ;

QNodo * _trasero ;

} cola ;

// Inicializar la cola

void QueueInit ( Cola * q );

// El final de la cola entra en la cola

void QueuePush ( Cola * q , datos QDataType );

// El jefe de la cola está fuera de la cola

void QueuePop ( Cola * q );

// Obtener el elemento al principio de la cola

QDataType QueueFront ( Cola * q );

// Obtener el elemento final de la cola

QDataType QueueBack ( Cola * q );

// Obtener el número de elementos válidos en la cola

int TamañoCola ( Cola * q );

// Comprueba si la cola está vacía, devuelve un resultado distinto de cero si está vacío, devuelve 0 si no está vacío

int ColaVacío ( Cola * q );

// destruir la cola

void Destrucción de Cola ( Cola * q );

// inicialización

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

//Encolar

//入列
void QueuePush(Que* pq, Qdatatype x)
{
	assert(pq);
	//开辟队列结构动态内存
	Qnode* newnode = (Qnode*)malloc(sizeof(Qnode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//第一次或N+1次
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

// quitar la cola

//出列
void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	
	if (pq->head->next == NULL)
	{
		//就剩下一个
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		//剩下两个及以上
		Que * del = pq->head;
		pq->head = pq->head->next;
		free(del);
		}

	pq->size--;
}

// Obtener el elemento al principio de la cola 

// 获取队列头部元素 
Qdatatype QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

// Obtener el elemento final de la cola 

// 获取队列队尾元素 
Qdatatype QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

// Obtener el número de elementos válidos en la cola 

// 获取队列中有效元素个数 
int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;
}

// Comprobar si la cola está vacía, devolver un resultado distinto de cero si está vacío y devolver 0 si no está vacío 

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Que* pq)
{
	assert(pq);

	return pq->head == NULL;
}

//destruir

//销毁
void QueueDestroy(Que* pq)
{
	assert(pq);
	while (pq->head)
	{
		Que* del = pq->head->next;
		free(pq->head);
		pq->head = del;
		pq->size--;
	}

	pq->head = pq->tail = NULL;
}

Conocimiento extendido:

        Las colas son adecuadas para la implementación mediante listas enlazadas. Se producirán problemas de desbordamiento falso cuando se utilicen estructuras secuenciales (es decir, espacios continuos fijos). Por lo tanto, los grandes han diseñado colas circulares. Las colas circulares están diseñadas para resolver el problema de los desbordamientos falsos en estructuras secuenciales.

        Cola circular: en la práctica, a veces usamos una cola llamada cola circular. Por ejemplo, cuando el curso del sistema operativo explica el modelo productor-consumidor, se puede usar una cola circular. Una cola circular se puede implementar utilizando una matriz o una lista enlazada circular.

 

        Al mismo tiempo, apunta a una posición que está vacía , y cuando la siguiente posición de la parte trasera (cola) es la delantera (cabeza), significa que se ha llenado . Aquí hay un espacio adicional para juzgar si está lleno o ¡no! ! !

 Lo anterior es mi opinión personal y mi análisis del aprendizaje de tablas lineales. ¡Bienvenidos todos a discutir en el área de comentarios!

¡Gracias por los chicos de tres conexiones con un solo clic! ¡Gracias por los chicos de tres conexiones con un solo clic! ¡Gracias por los chicos de tres conexiones con un solo clic!