From bbb5ee43a5562227d4e948de83f15b4e740453e6 Mon Sep 17 00:00:00 2001 From: Manuel Vergara Date: Sat, 22 Jun 2024 11:30:56 +0200 Subject: [PATCH] Update PEC6 --- fundamentos-programacion/PEC6/README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/fundamentos-programacion/PEC6/README.md b/fundamentos-programacion/PEC6/README.md index d3883f6..5391de8 100644 --- a/fundamentos-programacion/PEC6/README.md +++ b/fundamentos-programacion/PEC6/README.md @@ -180,14 +180,14 @@ En general, un TAD que representa secuencias de elementos posee las siguientes o Tabla comparativa de las diferencias entre Pila, Cola y Lista: -| Característica | Pila (Stack) | Cola (Queue) | Lista (List) | -| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| **Estructura de Datos** | Implementada típicamente con un arreglo estático o una lista enlazada. | Puede ser implementada con un arreglo estático o una lista enlazada. | Generalmente implementada con una lista enlazada o estructura dinámica. | -| **Principio de Acceso** | LIFO (Last In, First Out): Último en entrar, primero en salir. | FIFO (First In, First Out): Primero en entrar, primero en salir. | Acceso Aleatorio: Acceso directo a cualquier elemento. | -| **Operaciones Básicas** | `push(elemento)`: Añade un elemento al tope de la pila.
`pop()`: Elimina y retorna el elemento del tope de la pila.
`isEmpty()`: Verifica si la pila está vacía.
`isFull()`: Verifica si la pila está llena (en caso de implementación estática). | `enqueue(elemento)`: Añade un elemento al final de la cola.
`dequeue()`: Elimina y retorna el elemento al frente de la cola.
`isEmpty()`: Verifica si la cola está vacía.
`isFull()`: Verifica si la cola está llena (en caso de implementación estática). | `insertar(elemento)`: Inserta un elemento en la lista en una posición específica o al final.
`eliminar(elemento)`: Elimina un elemento de la lista.
`buscar(elemento)`: Busca un elemento específico en la lista. | -| **Implementación Común en C** | Puede ser implementada usando un arreglo estático con un índice que indica el tope, o con una lista enlazada donde cada nodo contiene el dato y un puntero al siguiente nodo. | Similar a la pila, puede usar un arreglo estático o una lista enlazada. En la implementación de arreglo, se usa un índice para controlar el frente y el final de la cola. | Implementada típicamente usando una lista enlazada donde cada nodo contiene el dato y un puntero al siguiente nodo, permitiendo inserciones y eliminaciones eficientes en cualquier posición. | -| **Eficiencia** | - Operaciones de `push()` y `pop()` son O(1) en una implementación con arreglo o lista enlazada.
- Espacio requerido puede ser menos flexible que una lista enlazada si se usa un arreglo estático. | - Operaciones de `enqueue()` y `dequeue()` son O(1) en una implementación con arreglo o lista enlazada.
- Requiere más espacio que una pila debido al almacenamiento de referencias de frente y final. | - Inserciones y eliminaciones pueden ser O(1) o O(n), dependiendo de si se inserta o elimina al principio o final de la lista.
- Búsqueda es O(n) en una lista simple enlazada sin optimizaciones adicionales. | -| **Uso Típico** | - Manejo de historial de llamadas (undo/redo).
- Evaluación de expresiones matemáticas (notación polaca inversa). | - Gestión de tareas en una cola (por ejemplo, impresión en una impresora).
- Algoritmos de búsqueda en grafos (BFS utiliza una cola para gestionar los nodos a visitar). | - Almacenamiento de datos que requieren acceso y modificación frecuente, pero no necesariamente en orden específico.
- Implementación de estructuras de datos más complejas como listas enlazadas dobles o listas circulares. | +| Característica | Pila (Stack) | Cola (Queue) | Lista (List) | +| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| **Estructura de Datos** | Implementada típicamente con un arreglo estático o una lista enlazada. | Puede ser implementada con un arreglo estático o una lista enlazada. | Generalmente implementada con una lista enlazada o estructura dinámica. | +| **Principio de Acceso** | LIFO (Last In, First Out): Último en entrar, primero en salir. | FIFO (First In, First Out): Primero en entrar, primero en salir. | Acceso Aleatorio: Acceso directo a cualquier elemento. | +| **Operaciones Básicas** | `initStack()`: Inicializa la pila vacía
`push(elemento)`: Añade un elemento al tope de la pila.
`pop()`: Elimina y retorna el elemento del tope de la pila.
`isEmptyStack()`: Verifica si la pila está vacía.
`isFullStack()`: Verifica si la pila está llena (en caso de implementación estática).
`heightStack()`: Devuelve número de elementos. | `initQueue()`: Inicializa cola
`enqueue(elemento)`: Añade un elemento al final de la cola.
`dequeue()`: Elimina y retorna el elemento al frente de la cola.
`head()`: Devuelve el elemento situado en el inicio.
`isEmptyQueue()`: Verifica si la cola está vacía.
`isFullQueue()`: Verifica si la cola está llena (en caso de implementación estática).
`lengthQueue`: Devuelve el número de elementos. | `initList()`: Inicia la lista vacía.
`insert(elemento)`: Inserta un elemento en la lista en una posición específica o al final.
`delete(elemento)`: Elimina un elemento de la lista.
`get(posición)`: Busca un elemento específico en una posición.
`isEnd(posición)`: Devuelve verdadero si la posición dada es posterior a la última.
`isEmptyList`: Verifica si la lista está vacía.
`isFullList`: Verifica si la lista está llena.
`lengthList`: Devuelve el número de elementos. | +| **Implementación Común en C** | Puede ser implementada usando un arreglo estático con un índice que indica el tope, o con una lista enlazada donde cada nodo contiene el dato y un puntero al siguiente nodo. | Similar a la pila, puede usar un arreglo estático o una lista enlazada. En la implementación de arreglo, se usa un índice para controlar el frente y el final de la cola. | Implementada típicamente usando una lista enlazada donde cada nodo contiene el dato y un puntero al siguiente nodo, permitiendo inserciones y eliminaciones eficientes en cualquier posición. | +| **Eficiencia** | - Operaciones de `push()` y `pop()` son O(1) en una implementación con arreglo o lista enlazada.
- Espacio requerido puede ser menos flexible que una lista enlazada si se usa un arreglo estático. | - Operaciones de `enqueue()` y `dequeue()` son O(1) en una implementación con arreglo o lista enlazada.
- Requiere más espacio que una pila debido al almacenamiento de referencias de frente y final. | - Inserciones y eliminaciones pueden ser O(1) o O(n), dependiendo de si se inserta o elimina al principio o final de la lista.
- Búsqueda es O(n) en una lista simple enlazada sin optimizaciones adicionales. | +| **Uso Típico** | - Manejo de historial de llamadas (undo/redo).
- Evaluación de expresiones matemáticas (notación polaca inversa). | - Gestión de tareas en una cola (por ejemplo, impresión en una impresora).
- Algoritmos de búsqueda en grafos (BFS utiliza una cola para gestionar los nodos a visitar). | - Almacenamiento de datos que requieren acceso y modificación frecuente, pero no necesariamente en orden específico.
- Implementación de estructuras de datos más complejas como listas enlazadas dobles o listas circulares. | Explicación de términos comunes: - **Arreglo estático**: Un arreglo con tamaño fijo determinado en tiempo de compilación.