Tema 2 TAD Lineales: Pila, Cola y Lista - informatica.utem.clinformatica.utem.cl/~mcast/ESDATOS/TADS/Ttema2_0506.pdf · Estructuras de Datos II I.T. en Informática de Gestión/Sistemas

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

Tema 2

2005 -2006

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 Pila2.2.1 Conceptos

2.2.2 Especificación algebraica2.2.3 Implementación2.2.4 Consideraciones sobre TAD basados en punteros2.2.5 El contenedor stack de la STL


Tema 2

2005 -2006


Contenidos

2.3 El TAD Cola

2.3.1 Conceptos2.3.2 Especificación algebraica2.3.3 Implementación2.3.4 El contenedor queue de la STL2.3.5 El TAD Doble cola

2.4 El TAD Lista

2.4.1 Conceptos2.4.2 Lista con índices2.4.3 Lista con iteradores2.4.4 Los contenedores vector y list de la STL


Tema 2

2005 -2006


Bibliografía

Data Structures and Algorithms in C++Autor: Michael T. Goodrich, Roberto Tamassia, David M. MountEditorial: John Wiley & Sons, Inc.Año: 2004Págs. 143 – 252

Estructuras de datos y métodos algorítmicosAutor: Narciso Martí Oliet y otrosEditorial : Prentice-Hall, 2004Págs. 39 – 146

Diseño de programas. Formalismo y abstracciónAutor: Ricardo Peña MaríEditorial : Prentice-Hall, 1999Págs. 227 – 234

Duración

5 clases (7.5 h)


Tema 2

2005 -2006


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:

existe un elemento llamado primero

existe un elemento llamado último

cada elemento, excepto el primero, tiene un único predecesor

cada elemento, excepto el último, tiene un único sucesor


Tema 2

2005 -2006


Operaciones básicas:

crear la estructura vacía

insertar un elemento

borrar un elemento

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

2005 -2006

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

a1

a2

a3

Cima de la pilaLos elementos se insertan de uno en uno (apilar)

Se sacan en el orden inverso al cual se han insertado (desapilar)

El único elemento que se puede observar dentro de la pila es el último insertado (cima)


Tema 2

2005 -2006

TAD Pila

Aplicaciones:

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)

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

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

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

2005 -2006

TAD Pila

2.2.2 Especificación algebraica

espec pilasusa booleanosparámetro formal

género elementofpfgénero pilaoperaciones

creaPila: pilaapilar: pila elemento pilaparcial desapilar: pila pilaparcial cima: pila elementovacía?: pila booleano

dominios de definición p: pila; e: elemento

ecuaciones p: pila; e: elementodesapilar (apilar (p, e)) =cima (apilar (p, e)) =vacia? (creaPila) =vacia? (apilar (p, e)) =

fespec

Cons (pila) =

Gen (pila) =

Mod (pila) =

Obs (pila) =


Tema 2

2005 -2006

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

creaPila: representa la pila sin ningún elemento (pila vacía)

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

2005 -2006

TAD Pila

template <typename T>Pila {

public:Pila();bool esVacia() const; const T& cima() const throw(PilaVaciaExcepcion);void apilar (const T& objeto);void desapilar() throw(PilaVaciaExcepcion);

}

2.2.3 Implementación

Interfaz informal

Paradigma TAD:

Es necesario especificar el tipo independientemente de su implementación

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


Tema 2

2005 -2006

TAD Pila

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

Transformación de la notación algebraica a OO


Tema 2

2005 -2006

TAD Pila

indCima

n

template <typename T>class PilaTabla {

public:PilaTabla(int tam = 10);PilaTabla(const PilaTabla& p);bool esVacia() const; 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;

}

Mediante una tabla

capacidad - 1...n-1...210

elementos ...en...e3e2e1 ...en...e3e2e1


Tema 2

2005 -2006

TAD Pila

Consideraciones:

si la pila no está vacía, el elemento almacenado en elementos[indCima - 1] corresponde a la cima de la pila

elementos[0] ≡ fondo de la pila

indCima = 0 ≡ pila vacía

Ventaja: todas las operaciones de la interfaz tienen un coste temporal constante O(1)

Inconvenientes:

reservar espacio de memoria para el máximo previsto de elementos

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

2005 -2006

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 arrayelementos

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

2005 -2006

TAD Pila

Constructor de copia para la clase PilaTabla

PilaTabla(const PilaTabla& p)var

int i;fvar;inicio

fin;


Tema 2

2005 -2006

TAD Pila

template <typename T>class PilaEnlazada {

typedef Nodo<T>* PtrNodo;public:

PilaEnlazada();PilaEnlazada(const PilaEnlazada& p);bool esVacia() const; const T& cima() throw(PilaVaciaExcepcion) const;void apilar (const T& objeto);void desapilar throw(PilaVaciaExcepcion);~PilaEnlazada();

private:PtrNodo c;

}

Ventajas:

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

no hay limitaciones de tamaño

Mediante una lista enlazada

...

c

e1 e2 e3


Tema 2

2005 -2006

TAD Pila

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

template <typename T>class Nodo {


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

2005 -2006

TAD Pila

2.2.4 Consideraciones sobre TAD basados en memoria dinámica

4 6 8

1 3 5

p

q

4 6 8

1 3 5

p

q

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


Tema 2

2005 -2006

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

2005 -2006

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() hacerdesapilar();

fmientras;fin;

Método destructor para la clase PilaTabla:

~PilaTabla()inicio

liberar [ ] elementos;fin;


Tema 2

2005 -2006

TAD Pila

2.2.4 El contenedor stack de la STL

Uso:

#include <stack>

// …

stack<tipo_base> p;


desapilarvoid pop()

apilarvoid push(const tipo_base&)

cimaconst tipo_base& top() const

esVaciabool empty() const

operador de asignaciónstack& operator=(const stack&)

constructor de copiastack(const stack&)

constructorstack()


Tema 2

2005 -2006

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, ...

2.3 El TAD Cola


Tema 2

2005 -2006

2.3.2 Especificación algebraica

espec colasusa booleanosparámetro formal

género elementofpfgénero colaoperaciones

creaCola: colaañadir: cola elemento colaparcial eliminar: cola colaparcial primero: cola elementovacía?: cola booleano

dominios de definición c: cola; e: elemento

TAD Cola

...


Tema 2

2005 -2006

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

2005 -2006

TAD Cola

ecuaciones c: cola; e: elementoeliminar (añadir (c, e)) =

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

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

fespec


Tema 2

2005 -2006

TAD Cola

2.3.3 Implementación

template <typename T>Cola {

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

}

Interfaz informal


Tema 2

2005 -2006

TAD Cola

template <typename T>class Cola {


Cola();Cola(const Cola& p);bool esVacia() const; const T& primero() const throw(ColaVaciaExcepcion);void añadir(const T& objeto);void eliminar() throw(ColaVaciaExcepcion);~Cola();

private:PtrNodo primero, ultimo;

}

...

primero

Cola

e1 e2 en

último Ventaja:

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


Tema 2

2005 -2006

TAD Cola

void añadir(const T& objeto)var

PtrNodo n;fvar;inicio

n = nuevo Nodo<T>(objeto);si esVacia() entonces

primero = n;sino

ultimo->setSig(n); fsi;ultimo = n;

fin;

Cola()inicio

primero = ultimo = NULO;fin;

void eliminar() throw(ColaVaciaExcepcion);var

PtrNodo inicio;fvar;inicio

si esVacia() entonceslanzar ColaVaciaExcepcion();

fsi;inicio = primero;si primero == ultimo entonces

ultimo = NULO;fsi;primero = primero->getSig();liberar inicio;

fin;


Tema 2

2005 -2006

TAD Cola

2.3.4 El contenedor queue de la STL

Uso:

#include <queue>

// …

queue<tipo_base> c;


eliminarvoid pop()

añadirvoid push(const tipo_base&)

primeroconst tipo_base& front() const


operador de asignaciónqueue& operator=(const queue&)

constructor de copiaqueue(const queue&)

constructorqueue()


Tema 2

2005 -2006

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

espec dobles-colasusa booleanos, naturalesparámetro formal

género elementofpfgénero dobleColaoperaciones

parcial -izq: dobleCola dobleCola parcial -dch: dobleCola dobleCola parcial izq: dobleCola elementoparcial dch: dobleCola elemento

creaDC: dobleCola+izq: elemento dobleCola dobleCola +dch: dobleCola elemento dobleCola vacía?: dobleCola booleano ...

Cons (dobleCola) =

Gen (dobleCola) =

Mod (dobleCola) =

Obs (dobleCola) =


Tema 2

2005 -2006

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

2005 -2006

TAD Cola

izq (+izq (e, c)) =

dch (+izq (e, c)) =

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

vacía? (creaDC) =vacía? (+izq (e, c)) =

fespec


Tema 2

2005 -2006

TAD Cola

Implementación

template <typename T>DobleCola {

public:DobleCola();bool esVacia() const; 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);

}

Interfaz informal


Tema 2

2005 -2006

TAD Cola

Lista simplemente enlazadaProblema:

eliminar el elemento de la derecha tieneun coste temporal lineal ⇒ O(n)

Lista doblemente enlazada

primero

Doble cola

último

...

Ventajas:

todas las operaciones de la interfaz tiene un coste temporal constante ⇒ O(1)

Los nodos centinelas simplifican las operaciones de inserción y eliminación

...

primero

Doble cola

e1 e2 en

último

...

primero

Doble cola

e1 e2 en

último

...

primero

Doble cola

e1 e2 en

último

e1 e2 en


Tema 2

2005 -2006

TAD Cola

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

template <typename T>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

2005 -2006

TAD Cola

template <typename T>class DobleCola {

typedef DobleNodo<T>* PtrDobleNodo;public:

DobleCola();DobleCola(const Cola& p);bool esVacia() const; 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);~DobleCola();

private:PtrDobleNodo primero, ultimo;

}

La clase DobleCola


Tema 2

2005 -2006

TAD Cola

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;

DobleCola()inicio

primero = nuevo DobleNodo<T>();último = nuevo DobleNodo<T>(primero, NULO);primero->setSig(ultimo);

fin;

void eliminarDer() throw (DobleColaVaciaExcepcion)var

PtrDobleNodo p;fvar;inicio

si esVacia() entonceslanzar DobleColaVaciaExcepcion();

fsi;p = ultimo->getAnt();p->getAnt()->setSig(ultimo);ultimo->setAnt(p->getAnt());liberar p;

fin;


Tema 2

2005 -2006

TAD Cola

El contenedor deque de la STL

Uso:

#include <deque>

// …

deque<tipo_base> dc;

eliminarIzqvoid pop_front()

añadirDervoid push_back(const tipo_base&)

observarDerconst tipo_base& back() const

eliminarDervoid pop_back()

añadirIzqvoid push_front(const tipo_base&)

observarIzqconst tipo_base& front() const


operador de asignacióndeque& operator=(const deque&)

constructor de copiadeque(const deque&)

constructordeque()



Tema 2

2005 -2006

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

2005 -2006

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

[ ]

+izq (e, l)Gen (lista) =


Tema 2

2005 -2006

TAD Lista

espec listasusa booleanos, naturalesparámetro formal

género elementooperaciones

_ == _: elemento elemento booleano_ ≠ _: elemento elemento booleano

fpfgénero listaoperaciones

parcial -izq: lista listaparcial -dch: lista listaparcial izq: lista elementoparcial dch: lista elementolongitud: lista naturalestá?: elemento lista booleano

[ ]: lista+izq: elemento lista lista[ _ ] : elemento lista_ & _ : lista lista lista+dch: lista elemento listavacía?: lista booleano ...

Existe una posición (índice) que sirve de referencia para las operaciones de inserción, consulta y modificación en cualquier posición

2.4.2 Lista con índices

Especificación algebraica


Tema 2

2005 -2006

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

2005 -2006

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

2005 -2006

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

2005 -2006

TAD Lista

Implementación

Interfaz informal template <typename T>Lista {

public:Lista();bool esVacia() const; int longitud() const;void añadirIzq(const T& objeto);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

2005 -2006

TAD Lista

Lista simplemente enlazada

La implementación más sencilla del TAD Lista es mediante una lista simplemente enlazada:

...

primero

e1 e2 en

ultimo

nnum

template <typename T>class Lista {

public:// operaciones del TAD

private:PtrNodo primero, ultimo;int num;

}


Tema 2

2005 -2006

TAD Lista

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

observarDch

eliminarDch

añadirDch

concatenar

esVacía

observarIzq

eliminarIzq

añadirIzq

costeoperación

posición

observar

modificar

eliminar

insertar

pertenece

longitud

costeoperación

n ≡ longitud de la lista

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


Tema 2

2005 -2006

TAD Lista

void eliminarDch() throw(ListaVaciaExcepcion);var

PtrNodo anterior;fvar;inicio

si esVacia() entonceslanzar ListaVaciaExcepcion();

fsisi num == 1entonces

liberar primero;primero = ultimo = NULO;

si noanterior = primero;mientras anterior->getSig() ≠ ultimo hacer

anterior = anterior->getSig();fmientrasanterior->setSig(NULO);liberar ultimo;ultimo = anterior;

fsinum--;

fin;

void añadirIzq(const T& objeto);var

PtrNodo n;fvar;inicio

n = nuevo Nodo(objeto, primero);primero = n;si num == 0 entonces

ultimo = n;fsi;num++;

fin;

Lista()inicio

primero = ultimo = NULO;num = 0;

fin;


Tema 2

2005 -2006

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

2005 -2006

TAD Lista

Especificación algebraica de iterador

espec iteradoresusa listas, naturalesparámetro formal

género elementofpfgénero iteradoroperaciones

inicio: lista iteradorparcial avanzar: lista iterador iteradorparcial observar: lista iterador elementoparcial posición: lista iterador natural

dominios de definición e: elemento; l: lista; it: iteradoravanzar (l, it) está definido sólo si 1 ≤ posición(l, it) ≤ longitud (l)observar (+izq(e, l), it) ∧

1 ≤ posición (+izq(e,l), it) ≤ longitud (+izq(e,l)) it es iterador de la lista que interviene en cada operación

ecuaciones l: lista; it: iteradorposición (l, inicio (l)) = 1posición (l, avanzar (l, it)) = 1 + posición (l, it)

observar (l, it) = l[posición (l, it)]fespec

Gen (iterador) =

Obs (iterador) =

NOTA: los iteradores pueden posicionarse desde el primer elemento de la lista hasta la posición siguiente al último elemento (denominaremos a esta posición final de lista)


Tema 2

2005 -2006

TAD Lista

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: naturalinsertar (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

Enriquecimiento de la especificación algebraica de lista con las operaciones con iteradores


Tema 2

2005 -2006

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

2005 -2006

TAD Lista

ecuaciones e: elemento; l: lista; it: iteradorinsertar (l, it, e) =

eliminar (l, it) =

modificar (l, it, e) =

observar (l, it) =fespec

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


Tema 2

2005 -2006

TAD Lista

Implementación

Interfaz informaltemplate <typename T>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);

}

template <typename T>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

2005 -2006

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

...

primero

Lista

e1 en

últimonum

anterior

IteradorEn este gráfico vemos un iterador apuntando al elemento e1. Este hecho representa, conceptualmente, al iteradorposicionado en el elemento e2


Tema 2

2005 -2006

TAD Lista

template <typename T>class Lista {


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);

};…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;const Iterador& ponerIterador(int posicion) const throw(IndiceErroneoExcepcion);

private:PtrNodo primero, ultimo;int num;

}

hacemos a la clase Lista amiga de la clase iterador para que los métodos de la clase Lista puedan acceder a su parte privada

el constructor de iterador es privado para que sólo lo utilicen los métodos de la clase Lista

La clase Iterador es una clase anidada de la clase Lista. Con esto se consiguen iteradorespropios para cada TAD


Tema 2

2005 -2006

TAD Lista

void insertar(const T& objeto, Iterador& it);inicio

it.anterior->setSig(nuevo Nodo(objeto, it.anterior->getSig()));si (it.anterior == ultimo) entonces ultimo = it.anterior -> getSig(); fsiit.anterior = it.anterior->getSig();num++;

fin;

Lista()inicio

primero = ultimo = nuevo Nodo();num = 0;

fin;

void eliminar(const Iterador& it) throw(PosicionErroneaExcepcion);inicio

si (it.anterior->getSig() == NULL) lanzar PosicionErroneaExcepcion();sinoPtrNodo p = it.anterior->getSig();si p = ultimo entonces ultimo = it.anterior; fsiit.anterior->setSig(p->getSig());delete p;num--;

fsifin;

const Iterador& principio()inicio

devuelve nuevo Iterador (primero);fin;

const Iterador& final()inicio

devuelve nuevo Iterador (ultimo);fin;


Tema 2

2005 -2006

TAD Lista

Hay que tener un especial cuidado con el uso de iteradores: se puede emplear un iteradordefinido para una lista en operaciones con otra lista

Puede evitarse incluyendo un tratamiento de excepciones que compruebe que el iteradorpertenece 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)

...

primero

Lista

e1 en

últimonum

lista anterior

Iterador


Tema 2

2005 -2006

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

Implementación dinámica con índices:

Implementación dinámica con iteradores:

template <typename T>

int ocurrencias(const Lista<T>& L, const T& elemento) {

int cont = 0;

for (typename Lista<T>::Iterador it = L.principio();

it != L.final(); it.avanzar(L))

if (it.observar(L) == elemento) cont++;

return (cont);

}

template <typename T>

int ocurrencias(const Lista<T>& L, const T& elemento) {

int cont = 0;

for (int i = 1 ; i <= L.longitud(); i++)

if (L.observar(i) == elemento) cont++;

return (cont);

}

(a) acceso por índice

(b) acceso con iteradores


Tema 2

2005 -2006

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

2005 -2006

TAD Lista

El contenedor vector de la STL

Uso:

#include <vector>

// …

vector<tipo_base> v;

elimina el elemento que ocupa la posición positerator erase(iterator pos)

longitudint size() const

devuelve un iterador al final del vectoriterator end()

devuelve un iterador al comienzo del vectoriterator begin()

añadirDervoid push_back(const T&)

inserta x delante de positerator insert(iterator pos, const tipo_base& x)

eliminarDervoid pop_back()

observarconst tipo_base& operator[](int n) const


operador de asignaciónvector& operator=(const vector&)

constructor de copiavector(const vector&)

constructorvector()



Tema 2

2005 -2006

TAD Lista

El contenedor list de la STLUso:

#include <list>

// …

list<tipo_base> l;

elimina el elemento que ocupa la posición positerator erase(iterator pos)

longitudint size() const

devuelve un iterador al final del vectoriterator end()

devuelve un iterador al comienzo del vectoriterator begin()

inserta x delante de positerator insert(iterator pos, const tipo_base& x)


operador de asignaciónlist& operator=(const lista&)

constructor de copialist(const list&)

constructorlist()



Tema 2

2005 -2006

TAD Lista

El concepto de bidirectional iterator de la STL

retrocede el iterador--i / i--

avanza el iterador++i / i++

modifica el elemento referenciado por i*i = e

devuelve el elemento referenciado por el iterador i*i

Expresiones válidas:

Documents

Tema 2 TAD Lineales: Pila, Cola y Lista - informatica.utem.clinformatica.utem.cl/~mcast/ESDATOS/TADS/Ttema2_0506.pdf · Estructuras de Datos II I.T. en Informática de Gestión/Sistemas