manuelver/Curso-lenguaje-C
manuelver/Curso-lenguaje-C
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Update PEC6

Browse Source
This commit is contained in:
Manuel Vergara 2024-06-22 11:30:56 +02:00
parent 49ba4fed2f
commit bbb5ee43a5
1 changed files with 8 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fundamentos-programacion/PEC6/README.md
View File

@ -181,10 +181,10 @@ 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. <br> `pop()`: Elimina y retorna el elemento del tope de la pila. <br> `isEmpty()`: Verifica si la pila está vacía. <br> `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. <br> `dequeue()`: Elimina y retorna el elemento al frente de la cola. <br> `isEmpty()`: Verifica si la cola está vacía. <br> `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. <br> `eliminar(elemento)`: Elimina un elemento de la lista. <br> `buscar(elemento)`: Busca un elemento específico en la lista. |
| **Operaciones Básicas** | `initStack()`: Inicializa la pila vacía <br> `push(elemento)`: Añade un elemento al tope de la pila. <br> `pop()`: Elimina y retorna el elemento del tope de la pila. <br> `isEmptyStack()`: Verifica si la pila está vacía. <br> `isFullStack()`: Verifica si la pila está llena (en caso de implementación estática). <br> `heightStack()`: Devuelve número de elementos. | `initQueue()`: Inicializa cola <br> `enqueue(elemento)`: Añade un elemento al final de la cola. <br> `dequeue()`: Elimina y retorna el elemento al frente de la cola. <br> `head()`: Devuelve el elemento situado en el inicio. <br> `isEmptyQueue()`: Verifica si la cola está vacía. <br> `isFullQueue()`: Verifica si la cola está llena (en caso de implementación estática). <br> `lengthQueue`: Devuelve el número de elementos. | `initList()`: Inicia la lista vacía. <br> `insert(elemento)`: Inserta un elemento en la lista en una posición específica o al final. <br> `delete(elemento)`: Elimina un elemento de la lista. <br> `get(posición)`: Busca un elemento específico en una posición. <br> `isEnd(posición)`: Devuelve verdadero si la posición dada es posterior a la última. <br> `isEmptyList`: Verifica si la lista está vacía. <br> `isFullList`: Verifica si la lista está llena. <br> `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. <br> - 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. <br> - 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. <br> - Búsqueda es O(n) en una lista simple enlazada sin optimizaciones adicionales. |
| **Uso Típico** | - Manejo de historial de llamadas (undo/redo). <br> - Evaluación de expresiones matemáticas (notación polaca inversa). | - Gestión de tareas en una cola (por ejemplo, impresión en una impresora). <br> - 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. <br> - Implementación de estructuras de datos más complejas como listas enlazadas dobles o listas circulares. |