Pilas, Colas. Andrea Rueda. Estructuras de Datos. Pontificia Universidad Javeriana Departamento de Ingeniería de Sistemas

Transcripción

1 Pilas, Colas Estructuras de Datos Andrea Rueda Pontificia Universidad Javeriana Departamento de Ingeniería de Sistemas

2 Quiz: STL

3 Quiz: STL Standard Template Library (STL) std::vector - Arreglo dinámico, crece en memoria según necesidad. - Acceso aleatorio con operador [] (sobrecargado). - Inserción y eliminación directa sólo en el final (cola) del arreglo.

4 Quiz: STL #include <vector> #include <iostream> int main() { } std::vector<int> arr; for (int i=0; i<6; i++) 1. Insertar algunos datos... arr.push_back(10 i); for (int ind=0; ind<arr.size(); ind++) 2. Imprimir los datos insertados en pantalla... std::cout << arr[ind] << " "; std::cout << std::endl;

5 Quiz: STL Standard Template Library (STL) std::deque - Cola de dos cabezas, arreglo dinámico que crece por ambos extremos. - Acceso aleatorio con operador [] (sobrecargado). - Inserción y eliminación directa tanto en la cabeza como en la cola.

6 Quiz: STL #include <iostream> #include <deque> int main() { std::deque<int> dcola; } for (int i=0; i<3; i++) { 3. dcola.push_back(i); Insertar algunos datos en dcola.push_front(10 i); ambos extremos... } for (int ind=0; ind<dcola.size(); ind++) 4. Imprimir los datos insertados en pantalla... std::cout << dcola[ind] << " "; std::cout << std::endl;

7 Quiz: STL Standard Template Library (STL) std::list - Lista doblemente encadenada, conexión al siguiente y al anterior. - Acceso directo a cabeza y cola, otros elementos a través de iteradores. - Inserción y eliminación directa tanto en la cabeza como en la cola.

8 #include <iostream> #include <list> int main() { std::list<int> lista; } Quiz: STL for (int i=0; i<3; i++) { 5. lista.push_back(i); Insertar algunos datos en lista.push_front(10 i); ambos extremos... } std::list<int>::iterator it; 6. Imprimir los datos insertados en pantalla... for (it=lista.begin(); it!=lista.end(); it++) std::cout << *it << " "; std::cout << std::endl;

9 Quiz: STL - vector #include <vector> #include <iostream> int main() { } std::vector<int> arr; for (int i=0; i<6; i++) arr.push_back(10 i); for (int ind=0; ind<arr.size(); ind++) std::cout << arr[ind] << " "; std::cout << std::endl;

10 Quiz: STL - deque #include <iostream> #include <deque> int main() { std::deque<int> dcola; } for (int i=0; i<3; i++) { dcola.push_back(i); dcola.push_front(10 i); } for (int ind=0; ind<dcola.size(); ind++) std::cout << dcola[ind] << " "; std::cout << std::endl;

11 #include <iostream> #include <list> int main() { std::list<int> lista; } Quiz: STL - list for (int i=0; i<3; i++) { lista.push_back(i); lista.push_front(10 i); } std::list<int>::iterator it; for (it=lista.begin(); it!=lista.end(); it++) std::cout << *it << " "; std::cout << std::endl;

12 TAD Pila TAD Cola

13 Pilas y colas Listas: propósito general (secuencias). Qué pasa cuando no sólo la secuencia es importante, sino el orden de llegada?

14 Pila Colección ordenada de elementos con restricciones de acceso. Sus elementos sólo pueden accederse por un único lugar, el tope o cima de la pila. Novela Enciclopedia Revista Libro Diccionario

15 Pila Entradas deben ser eliminadas en el orden inverso al que se situaron en la pila. último en entrar, primero en salir estructura de datos LIFO (last-in, first-out). insertar eliminar cima (tope) fondo

16 Pila Operaciones principales: Insertar (push): Añade un elemento y lo ubica en el tope de la pila. Eliminar (pop): Extrae el elemento en el tope y lo retira de la pila.

17 Pila Implementaciones: Arreglos (implementación estática). cima (tope) pila vacía puntero = -1 puntero de la pila pila llena puntero = 6

18 Pila Implementaciones: Listas enlazadas (implementación dinámica). cima (tope)

19 TAD Pila Secuencia finita de datos. Acceso sólo al elemento tope. Sin recorridos, acceso aleatorio restringido. Algoritmos: Insertar, eliminar. Vacía, tope. cima (tope) insertar Estado? eliminar fondo Interfaz?

20 TAD Pila TAD Pila Conjunto mínimo de datos: Comportamiento (operaciones) del objeto:

21 TAD Pila TAD Pila Conjunto mínimo de datos: - tope,?, representa el tope (elemento accesible). Comportamiento (operaciones) del objeto: - esvacia(), indica si la pila está vacía. - tope(), retorna el elemento en el tope. - insertar(v), inserta v en la pila. - eliminar(), elimina el elemento en el tope.

22 Pila en STL Stack (std::stack) No se puede iterar ( Por qué?) push (push_back) pop (pop_back) top (back) size empty

23 Pila en STL Declaración std::stack< int > aux; for (int i = 0; i < 12; i++) aux.push( i+1 ); Inserción de datos while(!aux.empty( ) ) { int n = aux.top( ); Extracción aux.pop( de ); datos std::cout << n << std::endl; }

24 Pila en STL std::stack< int > aux; for (int i = 0; i < 12; i++) aux.push( i+1 ); while(!aux.empty( ) ) { int n = aux.top( ); aux.pop( ); std::cout << n << std::endl; }

25 Cola Colección de elementos almacenados en una lista con restricciones de acceso. Los elementos sólo pueden ser insertados en la cola (final) de la lista, y sólo pueden ser eliminados por la cabeza (inicio o frente) de la lista Ult cabeza cola

26 Cola Entradas deben ser eliminadas en el mismo orden en el que se situaron en la cola. primero en entrar, primero en salir estructura de datos FIFO (first-in, first-out). Ejemplos: Atención a clientes en un almacén. Gestión de trabajos en una impresora.

27 Cola Operaciones principales: Insertar (push): Añadir un elemento por el extremo final de la cola. Eliminar (pop): Extraer el elemento ubicado en el extremo inicial de la cola.

28 Cola Implementaciones: - Arreglos (implementación estática). La cola no puede crecer indefinidamente, requiere un indicador de tamaño máximo. cabeza cola tamaño máximo

29 Cola Implementaciones: - Arreglos (implementación estática). después de insertar cabeza cola tamaño máximo después de eliminar cabeza cola tamaño máximo

30 Cola Implementaciones: - Arreglo circular (implementación estática). Se une el extremo final del arreglo con su extremo cabeza, para evitar las posiciones libres al inicio.

31 Cola Implementaciones: - Lista enlazada (implementación dinámica). cabeza cola

32 TAD Cola Secuencia finita de datos. Inserción por un extremo, eliminación por el otro. Sin recorridos, acceso aleatorio restringido Algoritmos: Insertar, eliminar. Vacía, cabeza. cabeza Estado? Interfaz? cola

33 TAD Cola TAD Cola Conjunto mínimo de datos: Comportamiento (operaciones) del objeto:

34 TAD Cola TAD Cola Conjunto mínimo de datos: - cabeza,?, representa el extremo inicial. - cola,?, representa el extremo final. Comportamiento (operaciones) del objeto: - esvacia(), indica si la cola está vacía. - cabeza(), retorna el elemento en la cabeza. - insertar(v), inserta v en la cola. - eliminar(), elimina el elemento en la cabeza.

35 Cola en STL Queue (std::queue) No se puede iterar ( Por qué?) push (push_back) pop (pop_front) front back size empty

36 Cola en STL Declaración std::queue< int > aux; for (int i = 0; i < 12; i++) aux.push( i+1 ); Inserción de datos while(!aux.empty( ) ) { int n = aux.front( ); Extracción aux.pop( de ); datos std::cout << n << std::endl; }

37 Cola en STL std::queue< int > aux; for (int i = 0; i < 12; i++) aux.push( i+1 ); while(!aux.empty( ) ) { int n = aux.front( ); aux.pop( ); std::cout << n << std::endl; }

38 Revisemos: Consideraciones de diseño e implementación de TADs

39 Diseño de TADs Plantilla base para diseño de TADs: TAD nombre Conjunto mínimo de datos: nombre valor (variable), tipo de dato, descripción... Comportamiento (operaciones) del objeto: nombre operación (argumentos), descripción funcional...

40 Diseño de TADs Diagrama de relación entre TADs: TAD 1 dato1 dato2 operacion1 operacion2 operacion3 TAD 2 dato1 dato2 operacion1 operacion2 TAD 3 Atención! No es un diagrama de clases! dato1 dato2 operacion1

41 Implementación de TADs Sintaxis básica, 2 archivos: - Encabezado (.h): Incluye la definición del TAD, en términos de datos y prototipos de operaciones. #include TAD.hxx (al final de la declaración) - Implementación (.hpp,.hxx): Incluye la implementación específica de las operaciones del TAD. #include TAD.h (al principio del archivo)

42 Implementación de TADs Implementación (opción 1): datos en estructura, operaciones como funciones adicionales. struct Carrera{ std::string nombre; unsigned long numest; }; std::string ObtenerNombre(Carrera *c); unsigned long ObtenerNumEst(Carrera *c); void FijarNombre(Carrera *c, std::string nombre); void AgregarEstud(Carrera *c); void EliminarEstud(Carrera *c);

43 Implementación de TADs Implementación (opción 2): datos y operaciones en estructura. struct Carrera{ std::string nombre; unsigned long numest; std::string ObtenerNombre(); unsigned long ObtenerNumEst(); void FijarNombre(std::string nombre); void AgregarEstud(); void EliminarEstud(); };

44 Implementación de TADs Implementación a usar (opción 3): Datos y operaciones dentro de una clase. class Carrera { public: Carrera(); std::string ObtenerNombre(); unsigned long ObtenerNumEst(); void FijarNombre(std::string name); void AgregarEstud(); void EliminarEstud(); protected: std::string nombre; unsigned long numest; };

45 Implementación de TADs Sintaxis básica en encabezado: - Regiones: Públicas (public): accesible por cualquiera. Protegidas (protected): públicas para clases derivadas, privadas para funciones externas. Privadas (private): accesible sólo por los miembros de la clase y por objetos de la misma clase.

46 Implementación de TADs Sintaxis básica en encabezado: - Regiones: Públicas (public): Todas las operaciones del TAD. Dan acceso a los datos (atributos) del TAD. Protegidas (protected) o Privadas (private): Todos los datos (atributos) del TAD.

47 Diseño e implementación de TADs 1.Diseñar el TAD: descripción + diagrama. 2.Escribir el archivo de encabezado (.h): un archivo por TAD. 3.Escribir el archivo de implementación (.hxx,.hpp): un archivo por TAD. 4.Escribir el archivo de programa (.cxx,.cpp): programa con procedimiento principal, incluye el encabezado de cada TAD a utilizar.

48 Ejercicio Carreras por facultades en una universidad : Ingeniería Ciencias Básicas Artes Ciencias Sociales Civil Biología Arquitectura Electrónica Música Sistemas

49 Composición Ejemplo: carreras por facultades en una universidad. class Carrera { public: Carrera(); std::string ObtenerNombre(); unsigned long ObtenerNumEst(); void FijarNombre(std::string name); void AgregarEstud(); void EliminarEstud(); protected: std::string nombre; unsigned long numest; };

50 Composición Ejemplo: carreras por facultades en una universidad. class Facultad { public: Facultad(); std::string ObtenerNombre(); void FijarNombre(std::string nombre); void AgregarCarrera(std::string carrera, unsigned long numest); unsigned long ContarEstud(); bool EliminarCarrera(std::string carrera); protected: std::string nombre; std::list<carrera> lcarreras; };

51 Composición Ejemplo: carreras por facultades en una universidad. class Universidad { public: Universidad(); void AgregarCarrera(std::string carrera, std::string fac, unsigned long numest); unsigned long ContarEstud(); void EliminarCarrera(std::string carrera); protected: std::list<facultad> lfacs; };

52 Referencias L. Joyanes Aguilar, I. Zahonero. Algoritmos y estructuras de datos: una perspectiva en C. McGraw-Hill,