Pila, Cola, Lista

Tema 2 TAD Lineales: Pila, Cola y Lista
Objetivos
Conocer los TAD lineales, su funcionamiento y aplicaciones

Conocer la especificación de cada uno de ellos
Saber realizar implementaciones alternativas
Saber usar los tipos lineales para resolver problemas
Conocer y utilizar los contenedores equivalentes de la STL
Contenidos
2.1 Introducción a las estructuras lineales

2.2 El TAD Pila
2.2.1 Conceptos
2.2.2 Especificación algebraica
2.2.3 Implementación
2.2.4 Consideraciones sobre TAD basados en punteros
2.2.5 El contenedor stack de la STL
2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 1

Contenidos
2.3 El TAD Cola

2.3.1 Conceptos
2.3.4 El contenedor queue de la STL
2.3.5 El TAD Doble cola
2.4 El TAD Lista

2.4.1 Conceptos
2.4.2 Lista con índices
2.4.3 Lista con iteradores
2.4.4 Los contenedores vector y list de la STL

Duración
5 clases (7.5 h)
Bibliografía
Data Structures and Algorithms in C++

Autor: Michael T. Goodrich, Roberto Tamassia, David M. Mount
Editorial: John Wiley & Sons, Inc.
Año: 2004
Págs. 143 – 252
Estructuras de datos y métodos algorítmicos
Autor: Narciso Martí Oliet y otros
Editorial : Prentice-Hall, 2004
Págs. 39 – 146
Diseño de programas. Formalismo y abstracción
Autor: Ricardo Peña Marí
Editorial : Prentice-Hall, 1999
Págs. 227 – 234

2.1 Introducción a las estructuras lineales
Estructuras lineales → importantes porque aparecen con frecuencia en muchos problemas
Ejemplos: una cola de clientes de un banco, la pila de ejecución de un programa, los

caracteres de una cadena o las páginas de un libro
Características:
5 existe un elemento llamado primero
5 existe un elemento llamado último
5 cada elemento, excepto el primero, tiene un único predecesor
5 cada elemento, excepto el último, tiene un único sucesor

Operaciones básicas:
5 crear la estructura vacía
5 insertar un elemento
5 borrar un elemento
5 obtener un elemento
Para definir claramente el comportamiento de la estructura es necesario determinar en qué

posición se inserta un elemento nuevo y qué elemento se borra o se obtiene
Principales estructuras lineales: pilas, colas y listas

Tema 2 TAD Pila
2.2 El TAD Pila
2.2.1 Conceptos
Una pila es un contenedor de objetos que son insertados y

eliminados de acuerdo con el principio de que el último en
entrar es el primero en salir (LIFO, Last Input First Output)
Apilar Desapilar
Cima de
Los elementos se insertan de uno en uno (apilar) la pila
a3
Se sacan en el orden inverso al cual se han insertado
(desapilar) a2
El único elemento que se puede observar dentro de
la pila es el último insertado (cima) a1

Tema 2 TAD Pila
Aplicaciones:
5 estructuras auxiliares en numerosos algoritmos y esquemas de programación:
recorridos de árboles y grafos
evaluación de expresiones
conversión entre notaciones de expresiones (postfija, prefija, infija)
5 gestión de los registros de activación de los subprogramas activos durante la ejecución

de un programa
5 los editores de texto proporcionan normalmente un botón deshacer que cancela las
operaciones de edición recientes y restablece el estado anterior del documento. La
secuencia de operaciones recientes se mantiene en una pila
5 los navegadores permiten habitualmente volver hacia atrás en la secuencia de páginas
visitadas. Las direcciones de los sitios visitados se almacenan en una pila

Tema 2 TAD Pila
espec pilas
usa booleanos
parámetro formal
género elemento
fpf Gen (pila) =
género pila
operaciones Cons (pila) =
creaPila: Æ pila Mod (pila) =
apilar: pila elemento Æ pila
parcial desapilar: pila Æ pila
parcial cima: pila Æ elemento
vacía?: pila Æ booleano
dominios de definición p: pila; e: elemento
Obs (pila) =
ecuaciones p: pila; e: elemento

desapilar (apilar (p, e)) =
cima (apilar (p, e)) =
vacia? (creaPila) =
vacia? (apilar (p, e)) =
fespec

Tema 2 TAD Pila
El conjunto de generadoras es libre, ya que cualquier término formado por las operaciones
generadoras denota siempre un valor distinto del TAD Pila
Los patrones necesarios para representar todas las posibles pilas se obtienen del conjunto
de las operaciones generadoras
5 creaPila: representa la pila sin ningún elemento (pila vacía)
5 apilar(p, e): representa cualquier pila con, al menos, un elemento
Las operaciones desapilar y cima no están definidas para la pila vacía

Tema 2 TAD Pila
Interfaz informal
Paradigma TAD:
5 Es necesario especificar el tipo independientemente de su implementación
5 Una interfaz es una lista de métodos que cualquier implementación del tipo debe
proporcionar
Aunque C++ no soporta de forma adecuada la definición de interfaces, para cada tipo
presentaremos una interfaz informal
template <typename T>
Pila {
public:
Pila();
bool esVacia() const;
const T& cima() const throw(PilaVaciaExcepcion);
void apilar (const T& objeto);
void desapilar() throw(PilaVaciaExcepcion);
}

Tema 2 TAD Pila
Transformación de la notación algebraica a OO
La operación constante creaPila se convierte en el constructor de la clase
El parámetro cuyo tipo es el que aparece en el género se convierte en el objeto sobre el

que se aplica el método
esVacía, cima y desapilar se transforman en métodos sin parámetros
apilar se transforma en un método con un único parámetro
Las operaciones parciales (cima y desapilar) se convierten en métodos que lanzan

excepciones para el subconjunto del dominio para el que no están definidas
Las operaciones observadoras (cima y vacía?) se implementan como métodos

constantes

Tema 2 TAD Pila
Mediante una tabla
elementos e1 e2 e3 ... en ...

n
0 1 2 ... n-1 ... capacidad - 1
indCima

class PilaTabla {
public:
PilaTabla(int tam = 10);
PilaTabla(const PilaTabla& p);
const T& cima() const throw(PilaVaciaExcepcion);
void apilar (const T& objeto) throw(PilaLlenaExcepción);
void desapilar throw(PilaVaciaExcepcion);
~PilaTabla ();
private:
int capacidad;
T* elementos;
int indCima;
}

Tema 2 TAD Pila
Consideraciones:
5 si la pila no está vacía, el elemento almacenado en elementos[indCima - 1] corresponde a
la cima de la pila
5 elementos[0] ≡ fondo de la pila
5 indCima = 0 ≡ pila vacía
Ventaja: todas las operaciones de la interfaz tienen un coste temporal constante O(1)
Inconvenientes:
5 reservar espacio de memoria para el máximo previsto de elementos
5 gestionar pila llena
• lanzar una excepción
• usar la clase vector de la STL
Opciones para controlar la parcialidad o situaciones de error

1. controlar el posible error dentro de la operación
2. proporcionar suficientes operaciones para que el propio usuario evite el error (como
sucede en la clase stack de la STL)

Tema 2 TAD Pila
En C++, se puede hacer una reserva dinámica de la memoria para los arrays mediante el
operador new
Por esa razón, en la parte privada de la clase no se declara un tamaño para el array
elementos
Será el constructor el que reserve el espacio necesario en función del tamaño especificado
como parámetro
PilaTabla(int tam = 10)

inicio
indCima = 0;
capacidad = tam;
elementos = nuevo T[capacidad];
fin;

Tema 2 TAD Pila
Constructor de copia para la clase PilaTabla
PilaTabla(const PilaTabla& p)
var
int i;
fvar;
inicio
fin;

Tema 2 TAD Pila
Mediante una lista enlazada template <typename T>
class PilaEnlazada {
typedef Nodo<T>* PtrNodo;
public:
c PilaEnlazada();
PilaEnlazada(const PilaEnlazada& p);
e1 e2 ... e3 const T& cima() throw(PilaVaciaExcepcion) const;
void apilar (const T& objeto);
void desapilar throw(PilaVaciaExcepcion);
~PilaEnlazada();
private:
PtrNodo c;
}
Ventajas:
5 todas las operaciones de la interfaz tienen un coste temporal constante ⇒ O(1)
5 no hay limitaciones de tamaño

Tema 2 TAD Pila
Se define una clase Nodo, que representa a cada uno de los objetos que forman
la lista enlazada

class Nodo {
public:
Nodo(const T& objeto);
Nodo(const T& objeto, PtrNodo psig);
Nodo(const Nodo& n);
const T& getObj() const;
PtrNodo getSig() const;
void setObj(const T& objeto);
void setSig(PtrNodo psig);
private:
T obj;
PtrNodo sig;
}

Tema 2 TAD Pila
2.2.4 Consideraciones sobre TAD basados en memoria dinámica
Si se realiza una asignación entre dos variables de tipo puntero (ej., p = q), no se realiza una
copia del valor del tipo (p.e. una pila completa), sino que se duplica la forma de acceder a
ella
p 4 6 8
q 1 3 5
4 6 8
p
q 1 3 5

Tema 2 TAD Pila
Constructor de copia para la clase PilaEnlazada

PilaEnlazada(const PilaEnlazada& p)
var
PtrNodo pv, n, antn;
fvar;
inicio
c = NULO;
pv = p.c;
si pv ≠ NULO entonces
n = nuevo Nodo<T>(pv->getObj());
c = n;
antn = n;
pv = pv->getSig();
mientras pv ≠ NULO hacer
n = nuevo Nodo<T>(pv->getObj());
antn->setSig(n);
antn = n;
pv = pv->getSig();
fmientras;
fsi
fin;

Tema 2 TAD Pila
Cuando dejamos de necesitar una estructura dinámica, debemos ocuparnos de liberar la

memoria
En caso contrario, esos objetos seguirán existiendo en memoria aunque no podamos
acceder a ellos (es el caso de la pila formada por los elementos 4-6-8 de la figura anterior)
Método destructor para la clase PilaEnlazada:
~PilaEnlazada()
inicio
mientras ⎤ esVacia() hacer
desapilar();
fmientras;
fin;
Método destructor para la clase PilaTabla:
~PilaTabla()
inicio
liberar [ ] elementos;
fin;

Tema 2 TAD Pila
2.2.4 El contenedor stack de la STL
Uso:
#include <stack>
// …
stack<tipo_base> p;
stack() constructor
stack(const stack&) constructor de copia
stack& operator=(const stack&) operador de asignación
bool empty() const esVacia
const tipo_base& top() const cima
void push(const tipo_base&) apilar
void pop() desapilar

Tema 2 TAD Cola
2.3 El TAD Cola
2.3.1 Conceptos
Los elementos se añaden por el extremo final, y se eliminan por el extremo opuesto: frente
El único elemento observable en todo momento es el primero que fue insertado
Se le suele denominar estructura FIFO (First Input First Output).
Aplicaciones
¾ Colas de trabajos a realizar por una impresora
¾ Asignación de tiempo de procesador a los procesos en un sistema multiusuario (sin

prioridad)
¾ Simular situaciones reales: cajero automático, llamadas en espera, ...

Tema 2 TAD Cola
espec colas
usa booleanos
parámetro formal
género elemento
fpf
género cola
operaciones
creaCola: Æ cola
añadir: cola elemento Æ cola
parcial eliminar: cola Æ cola
parcial primero: cola Æ elemento
vacía?: cola Æ booleano
dominios de definición c: cola; e: elemento
...
Tema 2 TAD Cola
Las operaciones son:

Gen (cola) =
Mod (cola) =
Obs (cola) =
¿El conjunto de generadoras es libre?
Los patrones necesarios para representar todas las posibles colas se obtienen del conjunto
de las operaciones generadoras
creaCola: representa la cola sin ningún elemento (cola vacía)
añadir(c, e): representa cualquier cola con, al menos, un elemento

Tema 2 TAD Cola
ecuaciones c: cola; e: elemento

eliminar (añadir (c, e)) =
primero (añadir (c, e)) =
vacia? (creaCola) =
vacia? (añadir (c, e)) =
fespec

Tema 2 TAD Cola
Interfaz informal

Cola {
public:
Cola();
const T& primero() const throw(ColaVaciaExcepcion);
void añadir(const T& objeto);
void eliminar() throw(ColaVaciaExcepcion);
}

Tema 2 TAD Cola
Cola
primero último Ventaja:

todas las operaciones de la interfaz tienen
e1 e2 ... en un coste temporal constante ⇒ O(1)

class Cola {
public:
Cola();
Cola(const Cola& p);
const T& primero() const throw(ColaVaciaExcepcion);
void añadir(const T& objeto);
void eliminar() throw(ColaVaciaExcepcion);
~Cola();
private:
PtrNodo primero, ultimo;
}

Tema 2 TAD Cola
Cola() void eliminar() throw(ColaVaciaExcepcion);

inicio var
primero = ultimo = NULO; PtrNodo inicio;
fin; fvar;
inicio
si esVacia() entonces
void añadir(const T& objeto) lanzar ColaVaciaExcepcion();
var fsi;
PtrNodo n; inicio = primero;
fvar; si primero == ultimo entonces
inicio ultimo = NULO;
n = nuevo Nodo<T>(objeto); fsi;
si esVacia() entonces primero = primero->getSig();
primero = n; liberar inicio;
sino fin;
ultimo->setSig(n);
fsi;
ultimo = n;
fin;

Tema 2 TAD Cola
2.3.4 El contenedor queue de la STL
Uso:
#include <queue>
// …
queue<tipo_base> c;
queue() constructor
queue(const queue&) constructor de copia
queue& operator=(const queue&) operador de asignación
const tipo_base& front() const primero
void push(const tipo_base&) añadir
void pop() eliminar

Tema 2 TAD Cola
2.3.5 El TAD Doble Cola
Permite consultar, añadir y eliminar elementos en cualquiera de los dos extremos de la

estructura lineal
Recibe también el nombre de bicola
Especificación algebraica Gen (dobleCola) =

espec dobles-colas Cons (dobleCola) =
usa booleanos, naturales
Mod (dobleCola) =
parámetro formal
género elemento
fpf Obs (dobleCola) =
género dobleCola
operaciones
creaDC: Æ dobleCola parcial -izq: dobleCola Æ dobleCola
+izq: elemento dobleCola Æ dobleCola parcial -dch: dobleCola Æ dobleCola
+dch: dobleCola elemento Æ dobleCola parcial izq: dobleCola Æ elemento
vacía?: dobleCola Æ booleano parcial dch: dobleCola Æ elemento ...
Tema 2 TAD Cola
dominios de definición e: elemento; c: dobleCola

-izq (+izq (e, c))
-dch (+izq (e, c))
izq (+izq (e, c))
dch (+izq (e, c))
ecuaciones e, e1, e2: elemento; c: dobleCola

+dch (creaDC, e) =
+dch (+izq (e1, c), e2) =
-izq (+izq (e, c)) =
-dch (+izq (e, c)) =
esta ecuación es equivalente a las ecuaciones

-dch (+izq (e, creaDC)) =
-dch (+izq ( e1, +izq (e2, c))) =
...
Tema 2 TAD Cola
izq (+izq (e, c)) =
dch (+izq (e, c)) =
esta ecuación es equivalente a las ecuaciones

dch (+izq (e, creaDC) =
dch (+izq (e1, +izq (e2, c))) =
vacía? (creaDC) =
vacía? (+izq (e, c)) =
fespec

Tema 2 TAD Cola
Implementación
Interfaz informal

DobleCola {
public:
DobleCola();
const T& observarIzq() const throw(DobleColaVaciaExcepcion);
const T& observarDer() const throw(DobleColaVaciaExcepcion);
void añadirIzq(const T& objeto);
void añadirDer(const T& objeto);
void eliminarIzq() throw(DobleColaVaciaExcepcion);
void eliminarDer() throw(DobleColaVaciaExcepcion);
}

Tema 2 TAD Cola
Lista simplemente enlazada
Problema:
Doble cola
eliminar el elemento de la derecha tiene
primero último un coste temporal lineal ⇒ O(n)
e1 e2 ... en
Ventajas:
5 todas las operaciones de la interfaz tiene un coste
Lista doblemente enlazada temporal constante ⇒ O(1)
Doble cola 5 Los nodos centinelas simplifican las operaciones de

inserción y eliminación
primero último
e1 e2 ... en

Tema 2 TAD Cola
Se define una clase DobleNodo, que representa a cada uno de los objetos que
forman la lista doblemente enlazada

class DobleNodo {
typedef DobleNodo<T>* PtrDobleNodo;
public:
DobleNodo();
DobleNodo(PtrDobleNodo pant, PtrDobleNodo psig);
DobleNodo(const T& objeto, PtrDobleNodo pant, PtrDobleNodo psig);
DobleNodo(const DobleNodo& n);
const T& getObj() const;
PtrDobleNodo getSig() const;
PtrDobleNodo getAnt() const;
void setObj(const T& objeto);
void setSig(PtrDobleNodo psig);
void setAnt(PtrDobleNodo pant);
private:
T obj;
PtrDobleNodo sig;
PtrDobleNodo ant;
}

Tema 2 TAD Cola
La clase DobleCola

class DobleCola {
typedef DobleNodo<T>* PtrDobleNodo;
public:
DobleCola();
DobleCola(const Cola& p);
const T& observarIzq() const throw(DobleColaVaciaExcepcion);
const T& observarDer() const throw(DobleColaVaciaExcepcion);
void añadirDer(const T& objeto);
void eliminarIzq() throw(DobleColaVaciaExcepcion);
void eliminarDer() throw(DobleColaVaciaExcepcion);
~DobleCola();
private:
PtrDobleNodo primero, ultimo;
}

Tema 2 TAD Cola
void eliminarDer() throw (DobleColaVaciaExcepcion)
DobleCola() var
inicio PtrDobleNodo p;
primero = nuevo DobleNodo<T>(); fvar;
último = nuevo DobleNodo<T>(primero, NULO); inicio
primero->setSig(ultimo); si esVacia() entonces
fin; lanzar DobleColaVaciaExcepcion();
fsi;
p = ultimo->getAnt();
p->getAnt()->setSig(ultimo);
ultimo->setAnt(p->getAnt());
liberar p;
fin;
void añadirIzq(const T& objeto)

var
PtrDobleNodo n;
fvar;
inicio
n = nuevo DobleNodo<T>(objeto, primero, primero->getSig());
primero->setSig(n);
n->getSig()->setAnt(n);
fin;

Tema 2 TAD Cola
Uso:
#include <deque>
El contenedor deque de la STL // …
deque<tipo_base> dc;
deque() constructor
deque(const deque&) constructor de copia
deque& operator=(const deque&) operador de asignación
Operaciones básicas: const tipo_base& front() const observarIzq
const tipo_base& back() const observarDer
void push_front(const tipo_base&) añadirIzq
void push_back(const tipo_base&) añadirDer
void pop_front() eliminarIzq
void pop_back() eliminarDer

Tema 2 TAD Lista
2.4 El TAD Lista

2.4.1 Conceptos
Generalización de los TAD Pila, Cola y Doble Cola
Secuencia de elementos en la que se permite el acceso para consultar, añadir o eliminar

elementos en cualquier posición
Suelen utilizarse como base para la construcción de otros TAD y estructuras de datos:
matrices dispersas (listas de listas)

árboles n-arios (listas de nodos "hermanos")
grafos (listas de adyacencia)

Tema 2 TAD Lista
Existen diversas formas de generar las listas. En nuestro caso elegimos un conjunto de
operaciones pequeño y libre
Nos apoyamos en la definición recursiva de secuencia de elementos: colección de

elementos del mismo tipo que:
; bien es vacío, en cuyo caso se denomina secuencia vacía
; bien se obtiene tras añadir por la izquierda un elemento a otra secuencia existente
Operaciones generadoras
[]
Gen (lista) =
+izq (e, l)

Tema 2 TAD Lista
2.4.2 Lista con índices
Existe una posición (índice) que sirve de referencia para las operaciones de inserción,
consulta y modificación en cualquier posición
espec listas Especificación algebraica
usa booleanos, naturales
parámetro formal
género elemento
operaciones
_ == _: elemento elemento Æ booleano
_ ≠ _: elemento elemento Æ booleano
fpf
género lista
operaciones
[ ]: Æ lista parcial -izq: lista Æ lista
+izq: elemento lista Æ lista parcial -dch: lista Æ lista
[ _ ] : elemento Æ lista parcial izq: lista Æ elemento
_ & _ : lista lista Æ lista parcial dch: lista Æ elemento
+dch: lista elemento Æ lista
longitud: lista Æ natural
vacía?: lista Æ booleano ...
está?: elemento lista Æ booleano

Tema 2 TAD Lista
parcial insertar: lista nat elemento Æ lista {insertar elemento i-ésimo}

parcial eliminar: lista nat Æ lista {eliminar elemento i-ésimo}
parcial modificar: lista nat elemento Æ lista {modificar elemento i-ésimo}
parcial _ [ _ ] : lista nat Æ elemento {elemento i-ésimo}
parcial pos: elemento lista Æ natural {posición del elemento}
dominios de definición e: elemento; l: lista; i: natural

-izq (+izq (e, l))
-dch (+izq (e, l))
izq (+izq (e, l))
dch (+izq (e, l))
insertar (l, i, e) está definido sólo si (1 ≤ i) ∧ (i ≤ long (l) + 1)
eliminar (l, i) está definido sólo si (1 ≤ i) ∧ (i ≤ long (l))
modificar (l, i, e) está definido sólo si (1 ≤ i) ∧ (i ≤ long (l))
l[i] está definido sólo si (1 ≤ i) ∧ (i ≤ long (l))
pos (e, l) está definido sólo si está? (e, l)
...
Tema 2 TAD Lista
ecuaciones e, e1, e2: elemento; l: lista; i: natural

[e] =
[]&l=
+izq (e, l1) & l2 =
long ([ ]) =
long (+izq (e, l)) =
está? (e, [ ]) =
está? (e1, +izq (e2, l)) =
insertar ([ ], i, e) =
insertar (+izq (e1, l), i, e2)) =
...
Tema 2 TAD Lista
eliminar (+izq (e, l), i) =
modificar (+izq (e1, l), i, e2) =
+izq (e, l) [i] =
pos (e1, +izq (e2, l)) =
fespec

Tema 2 TAD Lista
Implementación
Interfaz informal template <typename T>

Lista {
public:
Lista();
int longitud() const;
void añadirDch(const T& objeto);
void eliminarIzq() throw(ListaVaciaExcepcion);
void eliminarDch() throw(ListaVaciaExcepcion);
const T& observarIzq() const throw(ListaVaciaExcepcion);
const T& observarDch() const throw(ListaVaciaExcepcion);
void concatenar(const Lista& list);
bool pertenece(const T& objeto) const;
void insertar(int posicion, const T& objeto) throw(PosicionErroneaExcepcion);
void eliminar(int posicion) throw(PosicionErroneaExcepcion);
void modificar(int posicion, const T& objeto) throw(PosicionErroneaExcepcion);
const T& observar(int posicion) const throw(PosicionErroneaExcepcion);
int posicion(const T& objeto) const throw(ObjetoInexistenteExcepcion);
~Lista();
}

Tema 2 TAD Lista
Lista simplemente enlazada
La implementación más sencilla del TAD Lista es mediante una lista simplemente enlazada:
primero ultimo
e1 e2 ... en

class Lista { n
public: num
// operaciones del TAD
private:
PtrNodo primero, ultimo;
int num;
}

Tema 2 TAD Lista
En la siguiente tabla se observa el coste de las operaciones, para el peor caso, utilizando
este tipo de representación
operación coste operación coste

añadirIzq longitud
eliminarIzq pertenece
observarIzq insertar
esVacía eliminar
concatenar modificar
añadirDch observar
observarDch posición
eliminarDch
n ≡ longitud de la lista
¿Cómo se podría mejorar el coste de la operación eliminarDch?

Tema 2 TAD Lista
void eliminarDch() throw(ListaVaciaExcepcion);

Lista() var
inicio PtrNodo anterior;
primero = ultimo = NULO; fvar;
num = 0; inicio
fin; si esVacia() entonces
lanzar ListaVaciaExcepcion();
fsi
void añadirIzq(const T& objeto); si num == 1entonces
var liberar primero;
PtrNodo n; primero = ultimo = NULO;
fvar; si no
inicio anterior = primero;
n = nuevo Nodo(objeto, primero); mientras anterior->getSig() ≠ ultimo hacer
primero = n; anterior = anterior->getSig();
si num == 0 entonces fmientras
ultimo = n; anterior->setSig(NULO);
fsi; liberar ultimo;
num++; ultimo = anterior;
fin; fsi
num--;
fin;

Tema 2 TAD Lista
2.4.3 Lista con iteradores
Un iterador es una generalización del concepto de puntero

Un iterador asociado a una lista está formado por:
una lista L
una posición en L (posición actual)
un conjunto de operaciones para desplazar la posición actual dentro de L
Un iterador abstrae los aspectos de la representación interna de la lista y, en general, de

cualquier contenedor, durante los desplazamientos y accesos para lectura o escritura ⇒
proporciona una interfaz de uso independiente del contenedor
La ganancia en eficiencia de los iteradores se logra cuando se pretende realizar accesos
sucesivos a elementos consecutivos de una lista
Los accesos aleatorios mediante iteradores pueden no ser posibles o ser tan ineficientes
como los accesos mediante índices

Tema 2 TAD Lista
Especificación algebraica de iterador
espec iteradores dominios de definición e: elemento; l: lista; it: iterador

usa listas, naturales
avanzar (l, it) está definido sólo si 1 ≤ posición(l, it) ≤ longitud (l)
parámetro formal
observar (+izq(e, l), it) ∧
género elemento
1 ≤ posición (+izq(e,l), it) ≤ longitud (+izq(e,l))
fpf
it es iterador de la lista que interviene en cada operación
género iterador
operaciones
ecuaciones l: lista; it: iterador
inicio: lista Æ iterador
posición (l, inicio (l)) = 1
parcial avanzar: lista iterador Æ iterador
posición (l, avanzar (l, it)) = 1 + posición (l, it)
parcial observar: lista iterador Æ elemento
parcial posición: lista iterador Æ natural
observar (l, it) = l[posición (l, it)]
fespec
Gen (iterador) = NOTA: los iteradores pueden posicionarse desde el primer

elemento de la lista hasta la posición siguiente al último
Obs (iterador) =
elemento (denominaremos a esta posición final de lista)

Tema 2 TAD Lista
Enriquecimiento de la especificación algebraica de lista con las operaciones con iteradores
usa ..., iteradores
...
operaciones
parcial insertar: lista iterador elemento Æ lista {inserta un elemento delante del iterador }
parcial eliminar: lista iterador Æ lista {elimina el elemento posicionado en el iterador}
parcial modificar: lista iterador elemento Æ lista {modifica el elemento posicionado en el iterador}
parcial observar: lista iterador Æ elemento {obtiene el elemento posicionado en el iterador}
principio: lista Æ iterador {sitúa el iterador en el primer elemento de la lista}
final: lista Æ iterador {sitúa el iterador en la posición siguiente al último elemento}
parcial ponerIterador: lista natural Æ iterador {sitúa el iterador en la posición indicada por el parámetro}
dominios de definición e: elemento; l: lista; it: iterador; n: natural

insertar (l, it, e) está definido sólo si (1 ≤ posición(l, it)) ∧ (posición(l, it) ≤ longitud (l) + 1)
eliminar (l, it) está definido sólo si (1 ≤ posición(l, it) ∧ (posición(l, it) ≤ longitud (l))
modificar (l, it, e) está definido sólo si (1 ≤ posición(l, it)) ∧ (posición(l, it) ≤ longitud (l))
observar (l, it) está definido sólo si (1 ≤ posición(l, it)) ∧ (posición(l, it) ≤ longitud (l))
ponerIterador (l, n) está definido sólo si (1 ≤ n) ∧ (n ≤ longitud (l) + 1)
it es iterador de la lista que interviene en cada operación

Tema 2 TAD Lista
Ecuaciones para las nuevas operaciones:
ecuaciones e: elemento; l: lista; n: natural; it: iterador
principio (l) =
final (l) =
ponerIterador (l, n) =

Tema 2 TAD Lista
La semántica del resto de las operaciones con iteradores (insertar, eliminar, modificar y
observar) se describe en función de las operaciones análogas con índices. Simplemente
se utiliza como índice el resultado de la operación posición (l, it)
Aunque tengan el mismo nombre, al tener parámetros distintos, entendemos que estamos
haciendo sobrecargas de operaciones
ecuaciones e: elemento; l: lista; it: iterador

insertar (l, it, e) =
eliminar (l, it) =
modificar (l, it, e) =
observar (l, it) =

fespec

Tema 2 TAD Lista
Implementación
Interfaz informal Lista {
public:
…
void insertar(const Iterador& it, const T& objeto);
void eliminar(const Iterador& it) throw(PosicionErroneaExcepcion);
void modificar(const Iterador& it, const T& objeto) throw(PosicionErroneaExcepcion);
const T& observar(const Iterador& it) const throw(PosicionErroneaExcepcion);
const Iterador& principio() const;
const Iterador& final() const; {sitúa el iterador en la siguiente posición al último elemento}
const Iterador& ponerIterador(int posicion) const throw(IndiceErroneoExcepcion);
}

Iterador{
public:
void avanzar(const Lista& L) throw(PosicionErroneaExcepcion);
const T& observar(const Lista& L) const throw(PosicionErroneaExcepcion);
int posicion(const Lista& L) const;
}

Tema 2 TAD Lista
Como todos los tipos vistos hasta hora, los iteradores tienen una interfaz común,
independientemente del contenedor al que va a estar asociado
Sin embargo, su representación y la implementación de sus métodos dependerá de la
representación elegida para el contenedor (en este caso para la lista)
Con una implementación de lista simplemente enlazada, el iterador consiste en un puntero
al nodo anterior para que las operaciones de inserción y borrado sean eficientes. Además,
la lista debe tener un nodo centinela al principio para poder tratar al primer elemento
Lista
num primero último
e1 ... en
anterior
Iterador
En este gráfico vemos un iterador apuntando al elemento
e1. Este hecho representa, conceptualmente, al iterador
posicionado en el elemento e2

Tema 2 TAD Lista
class Lista {
typedef Nodo<T>* PtrNodo; hacemos a la clase Lista amiga de la clase iterador para
public: que los métodos de la clase Lista puedan acceder a su
parte privada
class Iterador {
friend class Lista<T>;
public:
void avanzar(const Lista& L) throw(PosicionErroneaExcepcion);
const T& observar(const Lista& L) const throw(PosicionErroneaExcepcion);
int posicion(const Lista& L) const;
private:
PtrNodo anterior;
Iterador (PtrNodo i);
}; el constructor de iterador es privado para que sólo lo utilicen
… los métodos de la clase Lista
void insertar(const Iterador& it, const T& objeto);
void modificar(const Iterador& it, const T& objeto) throw(PosicionErroneaExcepcion);
const T& observar(const Iterador& it) const throw(PosicionErroneaExcepcion);
const Iterador& principio() const;
const Iterador& final() const;
const Iterador& ponerIterador(int posicion) const throw(IndiceErroneoExcepcion);
private:
PtrNodo primero, ultimo; La clase Iterador es una clase anidada de la
int num;
}
clase Lista. Con esto se consiguen iteradores
propios para cada TAD

Tema 2 TAD Lista
void insertar(const T& objeto, Iterador& it);
Lista() inicio
inicio it.anterior->setSig(nuevo Nodo(objeto, it.anterior->getSig()));
primero = ultimo = nuevo Nodo(); si (it.anterior == ultimo) entonces ultimo = it.anterior -> getSig(); fsi
num = 0; it.anterior = it.anterior->getSig();
fin; num++;
fin;

inicio
si (it.anterior->getSig() == NULL) lanzar PosicionErroneaExcepcion();
sino
PtrNodo p = it.anterior->getSig();
si p = ultimo entonces ultimo = it.anterior; fsi
it.anterior->setSig(p->getSig());
delete p;
num--;
fsi
fin;
const Iterador& principio() const Iterador& final()

inicio inicio
devuelve nuevo Iterador (primero); devuelve nuevo Iterador (ultimo);
fin; fin;

Tema 2 TAD Lista
Hay que tener un especial cuidado con el uso de iteradores: se puede emplear un iterador
definido para una lista en operaciones con otra lista
Puede evitarse incluyendo un tratamiento de excepciones que compruebe que el iterador
pertenece a la lista con la que se quiere operar:
recorriendo la lista hasta encontrar el nodo al que apunta el iterador: O(n)
incluyendo en la implementación del iterador un puntero a la lista a la que pertenece: O(1)
Lista
num primero último
e1 ... en
lista anterior
Iterador

Tema 2 TAD Lista
Ejemplo de mejora de la eficiencia usando listas con iteradores:
Se desea saber el número de veces que aparece un elemento en una lista
template <typename T> template <typename T>

int ocurrencias(const Lista<T>& L, const T& elemento) int ocurrencias(const Lista<T>& L, const T& elemento)
{ {
int cont = 0; int cont = 0;
for (int i = 1 ; i <= L.longitud(); i++) for (typename Lista<T>::Iterador it = L.principio();
if (L.observar(i) == elemento) cont++; it != L.final(); it.avanzar(L))
return (cont); if (it.observar(L) == elemento) cont++;
} return (cont);
(a) acceso por índice }

(b) acceso con iteradores
Implementación dinámica con índices:

Implementación dinámica con iteradores:

Tema 2 TAD Lista
2.4.4 Los contenedores vector y list de la STL
Características del contenedor vector:

Es una secuencia que soporta acceso aleatorio en tiempo a constante a sus elementos mediante
un índice
Las inserciones y eliminaciones en el final se realizan en un tiempo de ejecución O(1)
Las inserciones y eliminaciones al comienzo o en medio del vector tienen un coste temporal lineal
El número de elementos en el vector puede variar de forma dinámica (la administración de
memoria es automática)
Características del contenedor list:

Está implementado como una lista doblemente enlazada ⇒ permite recorridos hacia delante y
hacia atrás (define iteradores bidireccionales)
Las inserciones y eliminaciones en los extremos se realizan en un tiempo de ejecución O(1)
Las inserciones no invalidan los iteradores a elementos de la lista. Las eliminaciones sólo invalidan
los iteradores que referencian a los elementos eliminados
Las operaciones de borrado o eliminación pueden cambiar los predecedores o sucesores de los
iteradores de una lista
También existe el contenedor slist, que implementa una lista simplemente enlazada

Tema 2 TAD Lista
El contenedor vector de la STL
vector() constructor
vector(const vector&) constructor de copia
vector& operator=(const vector&) operador de asignación
bool empty() const esVacia Uso:
int size() const longitud #include <vector>
const tipo_base& operator[](int n) const observar
// …
void push_back(const T&) añadirDer
vector<tipo_base> v;
void pop_back() eliminarDer
iterator begin() devuelve un iterador al comienzo del vector
iterator end() devuelve un iterador al final del vector
iterator insert(iterator pos, inserta x delante de pos
const tipo_base& x)
iterator erase(iterator pos) elimina el elemento que ocupa la posición pos

Tema 2 TAD Lista
El contenedor list de la STL
Uso:
#include <list>
// …
list<tipo_base> l;
list() constructor
list(const list&) constructor de copia
list& operator=(const lista&) operador de asignación
int size() const longitud
iterator begin() devuelve un iterador al comienzo del vector
iterator end() devuelve un iterador al final del vector
iterator insert(iterator pos, inserta x delante de pos
const tipo_base& x)
iterator erase(iterator pos) elimina el elemento que ocupa la posición pos

Tema 2 TAD Lista
El concepto de bidirectional iterator de la STL
Expresiones válidas:
*i devuelve el elemento referenciado por el iterador i

*i = e modifica el elemento referenciado por i
++i / i++ avanza el iterador
--i / i-- retrocede el iterador

Pila, Cola, Lista

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Pila, Cola, Lista

Cargado por

Copyright:

Formatos disponibles

Tema 2 TAD Lineales: Pila, Cola y Lista

 Conocer los TAD lineales, su funcionamiento y aplicaciones

2.1 Introducción a las estructuras lineales

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 1

2.3 El TAD Cola

2.4 El TAD Lista

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 2

 Data Structures and Algorithms in C++

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 3

 Estructuras lineales → importantes porque aparecen con frecuencia en muchos problemas

 Ejemplos: una cola de clientes de un banco, la pila de ejecución de un programa, los

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 4

 Para definir claramente el comportamiento de la estructura es necesario determinar en qué

 Principales estructuras lineales: pilas, colas y listas

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 5

 Una pila es un contenedor de objetos que son insertados y

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 6

5 gestión de los registros de activación de los subprogramas activos durante la ejecución

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 7

ecuaciones p: pila; e: elemento

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 8

 Las operaciones desapilar y cima no están definidas para la pila vacía

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 9

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 10

Transformación de la notación algebraica a OO

 La operación constante creaPila se convierte en el constructor de la clase

 El parámetro cuyo tipo es el que aparece en el género se convierte en el objeto sobre el

 Las operaciones parciales (cima y desapilar) se convierten en métodos que lanzan

 Las operaciones observadoras (cima y vacía?) se implementan como métodos

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 11

elementos e1 e2 e3 ... en ...

template <typename T>

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 12

 Opciones para controlar la parcialidad o situaciones de error

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 13

PilaTabla(int tam = 10)

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 14

 Constructor de copia para la clase PilaTabla

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 15

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 16

template <typename T>

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 17

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 18

 Constructor de copia para la clase PilaEnlazada

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 19

 Cuando dejamos de necesitar una estructura dinámica, debemos ocuparnos de liberar la

 Método destructor para la clase PilaEnlazada:

 Método destructor para la clase PilaTabla:

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 20

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 21

 El único elemento observable en todo momento es el primero que fue insertado

 Se le suele denominar estructura FIFO (First Input First Output).

¾ Colas de trabajos a realizar por una impresora

¾ Asignación de tiempo de procesador a los procesos en un sistema multiusuario (sin

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 22

 Las operaciones son:

 ¿El conjunto de generadoras es libre?

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 24

ecuaciones c: cola; e: elemento

primero (añadir (c, e)) =

2005 -2006 Estructuras de Datos II I.T. en Informática de Gestión/Sistemas Universidad de Huelva 25

template <typename T>

Conocer los TAD lineales, su funcionamiento y aplicaciones

Data Structures and Algorithms in C++

Estructuras lineales → importantes porque aparecen con frecuencia en muchos problemas

Ejemplos: una cola de clientes de un banco, la pila de ejecución de un programa, los

Para definir claramente el comportamiento de la estructura es necesario determinar en qué

Principales estructuras lineales: pilas, colas y listas

Una pila es un contenedor de objetos que son insertados y

Las operaciones desapilar y cima no están definidas para la pila vacía

La operación constante creaPila se convierte en el constructor de la clase

El parámetro cuyo tipo es el que aparece en el género se convierte en el objeto sobre el

Las operaciones parciales (cima y desapilar) se convierten en métodos que lanzan

Las operaciones observadoras (cima y vacía?) se implementan como métodos

Opciones para controlar la parcialidad o situaciones de error

Constructor de copia para la clase PilaTabla

Constructor de copia para la clase PilaEnlazada

Cuando dejamos de necesitar una estructura dinámica, debemos ocuparnos de liberar la

Método destructor para la clase PilaEnlazada:

Método destructor para la clase PilaTabla:

El único elemento observable en todo momento es el primero que fue insertado

Se le suele denominar estructura FIFO (First Input First Output).

Las operaciones son:

¿El conjunto de generadoras es libre?

Permite consultar, añadir y eliminar elementos en cualquiera de los dos extremos de la

Generalización de los TAD Pila, Cola y Doble Cola

Secuencia de elementos en la que se permite el acceso para consultar, añadir o eliminar

matrices dispersas (listas de listas)

Nos apoyamos en la definición recursiva de secuencia de elementos: colección de

¿Cómo se podría mejorar el coste de la operación eliminarDch?

Un iterador es una generalización del concepto de puntero

Un iterador abstrae los aspectos de la representación interna de la lista y, en general, de

Ecuaciones para las nuevas operaciones: