El documento describe diferentes estructuras de datos como pilas, colas y listas enlazadas. Explica que una pila es una estructura LIFO donde los elementos se agregan y eliminan de un extremo, mientras que una cola es una estructura FIFO donde los elementos se agregan a un extremo y eliminan del otro. También describe listas enlazadas y sus operaciones básicas como recorrer, insertar y eliminar nodos. Incluye ejemplos de código en C para implementar una lista enlazada genérica.

1. Estructura de Datos
• Luis Humeau
11-1155
• Waldi Saturno
12-0412

2. Pilas
Una pila es una método de estructuración datos
usando la forma LIFO (último en entrar, primero en
salir), que permite almacenar y recuperar datos.

3. Operaciones de las Pilas
Las operaciones que se pueden realizar con una
pila son:
• PUSH (pila, elemento):
Introduce un elemento en la pila. También se
le conoce como poner o meter.
• POP (pila):
Elimina un elemento de la pila. También
se le conoce como sacar o quitar.
• VACIA(pila):
Función booleana que indica si la pila esta
vacía o no.

4. Ejemplo

5. Ejemplo 2 Java
import java.util.*;
/**
*
* @author Tecnologia
*/
public class PILA {
public static void main(String[] args) {
Stack<String> pila = new Stack<String>();
for (int x=1;x <= 1000;x++)
pila.push(Integer.toString(x));
while (!pila.empty())
System.out.println(pila.pop());
}
}

6. COLAS
Una cola es una estructura de
datos, caracterizada por ser
una secuencia de elementos
en la que la operación de
inserción push se realiza por
un extremo y la operación de
extracción pop por el otro.
También se le llama estructura
FIFO (del inglés First In First
Out), debido a que el primer
elemento en entrar será
también el primero en salir.

7. Ejemplos
• Cola de automoviles esperando servicio en
una gasolinera.
• Cola de clientes en una ventanilla del banco
para pagar un servicio.
• Cola de programas en espera de ser
ejecutados por una computadora.

8. Tipos de Colas
• Cola Simple:
Estructura lineal donde los elementos salen en el mismo orden en
que llegan.
• Cola circular :
Representación lógica de una cola simple en un arreglo.
• Cola de Prioridades:
Estructura lineal en la cual los elementos se insertan en cualquier
posición de la cola y se remueven solamente por el frente.
• Cola Doble (Bicola) :
Estructura lineal en la que los elementos se pueden añadir o quitar
por cualquier extremo de la cola (Cola bidireccional).

9. Operaciones
1.- Insertar A
2.- Insertar B
3-.Insertar C
4-.Remover Elemento
5-. Insertar D
6.- Remover Elemento

10. Operaciones básicas en Colas Simples
• Insertar.- Almacena al final de la cola el elemento que
se recibe como parámetro.
• Eliminar.- Saca de la cola el elemento que se encuentra
al frente.
• Vacía.- Regresa un valor booleano indicando si la cola
tiene o no elementos (true – si la cola esta vacía, false
– si la cola tiene al menos un elemento).
• Llena.- Regresa un valor booleano indicando si la cola
tiene espacio disponible para insertar nuevos
elementos ( true – si esta llena y false si existen
espacios disponibles).

11. Colas-Utilización
Las colas se utilizan en sistemas informáticos,
transportes y operaciones de investigación
(entre otros), dónde los objetos, personas o
eventos son tomados como datos que se
almacenan y se guardan mediante colas para
su posterior procesamiento. Este tipo de
estructura de datos abstracta se implementa
en lenguajes orientados a objetos mediante
clases, en forma de listas enlazadas.
Una cola es una estructura de datos,
caracterizada por ser una secuencia de
elementos en la que la operación de inserción
push se realiza por un extremo y la operación
de extracción pop por el otro. También se le
llama estructura FIFO (del inglés First In First
Out), debido a que el primer elemento en
entrar será también el primero en salir.

12. Operaciones Básicas
• Crear:
– se crea la cola vacía.
• Encolar (añadir, entrar, insertar):
– se añade un elemento a la cola. Se añade al final de esta.
• Desencolar (sacar, salir, eliminar):
– se elimina el elemento frontal de la cola, es decir, el primer elemento
que entró.
• Frente (consultar, front):
– se devuelve el elemento frontal de la cola, es decir, el primer
elemento que entró.

13. Colas-JAVA

14. Lista
• En Ciencias de la Computación, una lista enlazada es una de
las estructuras de datos fundamentales, y puede ser usada
para implementar otras estructuras de datos. Consiste en una
secuencia de nodos, en los que se guardan campos de datos
arbitrarios y una o dos referencias (punteros) al nodo anterior
o posterior. El principal beneficio de las listas enlazadas
respecto a los array convencionales es que el orden de los
elementos enlazados puede ser diferente al orden de
almacenamiento en la memoria o el disco, permitiendo que el
orden de recorrido de la lista sea diferente al de
almacenamiento.

15. Lista (estructura de datos)
• Una lista enlazada es un tipo de dato auto-
referenciado porque contienen un puntero o link a
otro dato del mismo tipo. Las listas enlazadas
permiten inserciones y eliminación de nodos en
cualquier punto de la lista en tiempo constante
(suponiendo que dicho punto está previamente
identificado o localizado), pero no permiten un
acceso aleatorio. Existen diferentes tipos de listas
enlazadas: Lista Enlazadas Simples, Listas
Doblemente Enlazadas, Listas Enlazadas Circulares y
Listas Enlazadas Doblemente Circulares.

16. Lista
• Las listas enlazadas pueden ser
implementadas en muchos lenguajes.
Lenguajes tales como Lisp y Scheme tiene
estructuras de datos ya construidas, junto con
operaciones para acceder a las listas
enlazadas. Lenguajes imperativos u orientados
a objetos tales como C o C++ y
Java, respectivamente, disponen de
referencias para crear listas enlazadas.

17. Operaciones basicas de una lista.
• Recorrer los elementos hacia adelante
• Recorrer los elementos hacia atras
• Insertar un nuevo elemento al principio
• Insertar un nuevo elemento al final
• Insertar un nuevo elemento antes de otro
• Insertar un nuevo elemento despues de otro
• Remover un elemento del principio
• Remover un elemento que esta antes que otro
• Remover un elemento que esta despues de otro
• Remover un elemento del principio
• Remover un elemento del final

18. Implementación de una lista enlazada en
C
• #include <stdio.h> /* for printf */
• #include <stdlib.h> /* for malloc */
•
• typedef struct ns {
• int data;
• struct ns *next;
• } node;
•
• node *list_add(node **p, int i) {
• /* algunos compiladores no requieren un casting del valor del retorno para malloc */
• node *n = (node *)malloc(sizeof(node));
• if (n == NULL)
• return NULL;
• n->next = *p;
• *p = n;
• n->data = i;

19. Implementación de una lista enlazada en
C
• return n;
• }
•
• void list_remove(node **p) { /* borrar cabeza*/
• if (*p != NULL) {
• node *n = *p;
• *p = (*p)->next;
• free(n);
• }
• }
•
• node **list_search(node **n, int i) {
• while (*n != NULL) {
• if ((*n)->data == i) {
• return n;
• }

20. Implementación de una lista enlazada en
C
• n = &(*n)->next;
• }
• return NULL;
• }
•
• void list_print(node *n) {
• if (n == NULL) {
• printf("lista esta vacían");
• }
• while (n != NULL) {
• printf("print %p %p %dn", n, n->next, n->data);
• n = n->next;
• }
• }
•
• int main(void) {

21. Implementación de una lista enlazada en
C
• node *n = NULL;
•
• list_add(&n, 0); /* lista: 0 */
• list_add(&n, 1); /* lista: 1 0 */
• list_add(&n, 2); /* lista: 2 1 0 */
• list_add(&n, 3); /* lista: 3 2 1 0 */
• list_add(&n, 4); /* lista: 4 3 2 1 0 */
• list_print(n);
• list_remove(&n); /* borrar primero(4) */
• list_remove(&n->next); /* borrar nuevo segundo (2) */
• list_remove(list_search(&n, 1)); /* eliminar la celda que contiene el 1 (primera) */
• list_remove(&n->next); /* eliminar segundo nodo del final(0)*/
• list_remove(&n); /* eliminar ultimo nodo (3) */
• list_print(n);
•
• return 0;
• }

22. Fuente
1. http://es.kioskea.net/faq/2885-las-pilas-en-lenguaje-c
2. http://estructura-de-datos-garo.blogspot.com/2011/10/colas-informatica.html
3. http://www.slideshare.net/dma1991/colas-informaticas
4. http://www.madsgroup.org/docencia/alg/pilas_colas_listas.pdf