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.