Pilas, Colas - Departamento de Ingeniería de Sistemas

Pilas, Colas
Estructuras de Datos
Andrea Rueda
Pontificia Universidad Javeriana
Departamento de Ingeniería de Sistemas
Quiz: STL
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.
www.cplusplus.com/reference/vector/vector
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;
}
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.
www.cplusplus.com/reference/deque/deque
Quiz: STL
#include <iostream>
#include <deque>
int main() {
std::deque<int> dcola;
for (int i=0; i<3; i++) {
3. Insertar algunos datos
dcola.push_back(i);
dcola.push_front(10­i);
en 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;
}
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.
www.cplusplus.com/reference/list/list
Quiz: STL
#include <iostream>
#include <list>
int main() {
std::list<int> lista;
for (int i=0; i<3; i++) {
lista.push_back(i);
5. Insertar algunos datos
lista.push_front(10­i);
en ambos extremos...
}
std::list<int>::iterator it;
for (it=lista.begin(); it!=lista.end(); it++)
6. Imprimir los datos insertados en pantalla...
std::cout << *it << " ";
std::cout << std::endl;
}
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;
}
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;
}
Quiz: STL - list
#include <iostream>
#include <list>
int main() {
std::list<int> lista;
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;
}
TAD Pila
TAD Cola
Pilas y colas
●
●
Listas: propósito general (secuencias).
¿Qué pasa cuando no sólo la secuencia es
importante, sino el orden de llegada?
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
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
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.
Pila
●
Implementaciones:
–
Arreglos (implementación estática).
cima
(tope)
pila vacía
puntero = -1
puntero de
la pila
pila llena
puntero = 6
Pila
●
Implementaciones:
–
Listas enlazadas (implementación dinámica).
cima
(tope)
TAD Pila
●
Secuencia finita de
datos.
–
●
●
Acceso sólo al
elemento tope.
insertar
eliminar
cima
(tope)
Sin recorridos, acceso
aleatorio restringido.
Algoritmos:
–
Insertar, eliminar.
–
Vacía, tope.
fondo
¿Estado?
¿Interfaz?
TAD Pila
TAD Pila
Conjunto mínimo de datos:
Comportamiento (operaciones) del objeto:
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.
Pila en STL
Stack (std::stack)
●
No se puede iterar (¿Por qué?)
●
push (push_back)
●
pop (pop_back)
●
top (back)
●
size
●
empty
www.cplusplus.com/reference/stack/stack
Pila en STL
std::stack< int > aux;
Declaración
for (int i = 0; i < 12; i++)
aux.push( i+1 );
Inserción de datos
while( !aux.empty( ) ) {
int n = aux.top( );
aux.pop( );
Extracción de datos
std::cout << n << std::endl;
}
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;
}
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 .
1° 2° 3° 4° Ult
cabeza
cola
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.
https://www.citrix.com/blogs/2013/06/28/efficient-queuing-but-where/
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 .
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
Cola
●
Implementaciones:
- Arreglos (implementación estática).
después de
insertar
cabeza
cola
tamaño
máximo
cola
tamaño
máximo
después de
eliminar
cabeza
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.
http://pages.cpsc.ucalgary.ca/~jacobs/Courses/cpsc331/F10/tutorials/tutorial8.html
Cola
●
Implementaciones:
- Lista enlazada (implementación dinámica).
cabeza
cola
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
TAD Cola
TAD Cola
Conjunto mínimo de datos:
Comportamiento (operaciones) del objeto:
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.
Cola en STL
Queue (std::queue)
●
No se puede iterar (¿Por qué?)
●
push (push_back)
●
pop (pop_front)
●
front
●
back
●
size
●
empty
www.cplusplus.com/reference/queue/queue
Cola en STL
std::queue< int > aux;
Declaración
for (int i = 0; i < 12; i++)
aux.push( i+1 );
Inserción de datos
while( !aux.empty( ) ) {
int n = aux.front( );
aux.pop( );
Extracción de datos
std::cout << n << std::endl;
}
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;
}
Revisemos:
Consideraciones de diseño
e implementación de TADs
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
...
Diseño de TADs
●
Diagrama de relación entre TADs:
TAD 1
TAD 2
dato1
dato2
dato1
dato2
operacion1
operacion2
operacion3
operacion1
operacion2
TAD 3
Atención!
No es un diagrama
de clases!
dato1
dato2
operacion1
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)
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);
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();
};
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;
};
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.
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.
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.
Ejercicio
●
Carreras por facultades en una universidad :
Ingeniería
Ciencias
Básicas
Artes
Civil
Biología
Arquitectura
Electrónica
Sistemas
Música
Ciencias
Sociales
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;
};
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;
};
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;
};
Referencias
●
L. Joyanes Aguilar, I. Zahonero. Algoritmos y
estructuras de datos: una perspectiva en C.
McGraw-Hill, 2004.
●
www.sgi.com/tech/stl
●
www.cplusplus.com