EPED.07.Tema4.Tiposabstractosdedatoslineales.listas

Javier Vlez Reyes Jos Ignacio Mayorga [email protected] [email protected]

Departamento de Lenguajes Y Sistemas InformticosUNED

Estrategias de programacin y estructuras de datosGrado en Ingeniera Informtica

Grado en Tecnologas de la Informacin

Departamento de Lenguajes y Sistemas informticos

Tipos abstractos de datos linealesListas

Tipos abstractos de datos lineales. Listas

Javier Vlez Reyes [email protected] Jos Ignacio Mayorga Toledano [email protected] .es

ndice

ndice

Introduccin

Tipos abstractos de datos lineales

El tipo abstracto de datos lista

Interfaz del tipo abstracto de datos lista

Implementaciones del tipo abstracto de datos lista

Implementacin dinmica

Implementacin esttica

Algoritmos sobre listas

Recorrido de los elementos de una lista

Bsqueda de un elemento sobre una lista

Ordenacin de los elementos de una lista

Ejercicios

Bibliografa



Objetivos generales

Objetivos

Comprender que son los tipos abstractos de datos lineales

Conocer la interfaz del tipo abstracto de datos Lista

Aprender a implementar el TAD Lista mediante la interfaz ListIF

En versin esttica (con limitacin explcita de capacidad mxima)

En versin dinmica (sin limitacin explcita de capacidad mxima)

Conocer los principales problemas algortmicos sobre listas




Practicar el diseo de funciones recursivas sobre listas



Introduccin


Los tipos abstractos de datos lineales representan abstracciones en las que los datos sonorganizados de forma secuencial. A continuacin se muestran los diferentes TADs que caendentro de esta categora y que se diferencian, esencialmente, en la forma en que se ofrecenacceso a sus datos


I. Listas

II. Pilas

III. Colas

El tipo abstracto de datos Lista representa una estructuras de datosdonde los elementos se disponen de forma secuencial y lasoperaciones de insercin y extraccin se aplican por el principio,que puede moverse recursivamente haciendo referencia a otrassublistas

El tipo abstracto de dato Pila representa una estructuras de datosdonde los elementos se disponen de forma secuencial y lasoperaciones de insercin y extraccin se aplican por el principiosegn la poltica de acceso ltimo en entrar, primero en salir

El tipo abstracto de dato Cola representa una estructuras de datosdonde los elementos se disponen de forma secuencial y lasoperaciones de insercin y extraccin se aplican por el final y por elprincipio respectivamente de acuerdo a la poltica de primero enentrar, primero en salir

Tema 4

Tema 5

Tema 6



Introduccin

El tipo abstracto de datos lista

Las listas son abstracciones de datos que organizan una coleccin de elementos de manerasecuencial, donde a cada elemento le sigue un nico elemento siguiente. La definicin deltipo es recursiva lo que condiciona su forma de acceso. Una lista de tamao n se definecomo un primer elemento accesible seguido de una lista de tamao n 1 tambin accesible

Una lista es un tipo abstractos de datos que organiza una coleccin de elementos

de forma secuencial. Su definicin recursiva distingue una cabeza y un resto de

lista ambos accesibles. Las inserciones se realizan por delante de la cabeza

1 2 3 4 5 6 7 8 9

PrimeroToda lista no vaca distingue un primer

elemento que puede ser operado

directamente

RestoEl resto de elementos son accesibles a travs de la lista resto que es de tamao un elemento menor

ListaLa definicin de la lista como un par (primero, resto) induce unacceso recursivo a la misma donde los elementos se acceden porla cabeza (posicin del primero) y para llegar al elemento i-esimohay que recorrer los i-1 elementos anteriores



Interfaz del tipo abstracto de datos Lista

La interfaz del tipo abstracto de datos Lista ListIF

public interface ListIF{

/*** Devuelve la cabeza de una lista.* @return la cabeza de una lista.*/

public T getFirst ();

/*** Devuelve la lista excluyendo la cabeza.* @return la lista excluyendo la cabeza.*/

public ListIF getTail ();

/*** Inserta un nuevo elemento a la lista.* @param element El elemento a aadir.* @return la lista incluyendo el elemento.*/

public ListIF insert (T element);

/*** Devuelve cierto si la lista esta vacia.* @return cierto si la lista esta vacia.*/

public boolean isEmpty ();

/*** Devuelve cierto si la lista esta llena.* @return cierto si la lista esta llena.*/

public boolean isFull();

El interfaz de listas que utilizaremos a lo largo de estecurso, ListIF esta compuesto por las operaciones quedescribimos a continuacin

Primero y restoLas operaciones primero y restos son losprincipales mtodos de acceso recursivo a loselementos de la lista. Se trata de operacionesconsultoras que no modifican el estado de tipo

1

La operacin se insercin aade un elementodelante de la cabeza de la lista. Junto con laordenacin, es la nica operacin modificadora

Insertar

2 31

2 31

Est llena y est vacaLos predicados lgicos isEmpty y isFull indican el estado de la listaen relacin con el nmero de elementos que contiene. isEmptydevuelve cierto si la pila no contiene elementos. En este casogetFirst devuelve null y getTail devuelve la propia lista vaca. Enimplementaciones con capacidad isFull devuelve cierto si elnumero de elemento ha llegado a la capacidad. Enimplementaciones dinmicas siempre devuelve falso



Interfaz del tipo abstracto de datos Lista

La interfaz del tipo abstracto de datos Lista ListIF

/*** Devuelve el numero de elementos de la lista.* @return el numero de elementos de la lista.*/

public int getLength ();

/*** Devuelve un iterador para la lista.* @return un iterador para la lista.*/

public IteratorIF getIterator ();

/*** Devuelve cierto si la lista contiene el elemento.* @param element El elemento buscado.* @return cierto si la lista contiene el elemento.*/

public boolean contains (T element);

/*** Ordena los elementos de la lista.* @param element El comparador de elementos.* @return la lista ordenada.*/

public ListIF sort (ComparatorIF comparator);

}

El interfaz de listas que utilizaremos a lo largo de estecurso, ListIF esta compuesto por las operaciones quedescribimos a continuacin

LongitudLa longitud de la lista se refiere al nmero de elementos questa contiene. Este mtodo junto con los dos anteriores son lasherramientas necesarias para identificar los casos base en laestructura recursiva

ContieneEl predicado contiene realiza una bsqueda sobre loselementos de la lista para comprobar si cierto dato pasadocomo parmetro est incluido entre ellos

OrdenarOrdena los elementos de la lista deacuerdo al criterio de ordenimplementado en el comparador. Es unaoperacin modificadora

1 23

2 31

antes

despus

RecorridoDevuelve un iterador que permiterecorrer los elementos de la lista en elorden en que aparecen. Esta operacinno es modificadora del tipo

1 23

1 23

lista

Iterador de elementos



Implementacin del tipo abstracto de datos Lista

Implementacin del tipo abstracto de datos Lista ListIF

Existen varias estrategias para implementar listas que respondan al interfaz ListIF anterior.En general, stas se dividen en implementaciones dinmicas, que articulan listas decapacidad indefinida e implementaciones estticas, con una capacidad mxima limitada yestablecida como parmetro. Aqu presentamos un ejemplo de cada caso

Implementacin dinmica basada en primero y siguienteSegn esta estrategia de implementacin, una lista est formada por un atributo querepresenta la cabeza y otro que es una referencia a una lista que representa el resto de lalista. De esta manera una lista es una coleccin encadenada de pares (primero, resto).

1 2 3 4 - -

Primero y restoCada objeto Lista contiene un atributo pararepresentar el elemento en cabeza de lista yun atributo del tipo definido ListIF querepresenta una referencia al resto deelementos tras la cabeza

Ultimo, elemento fantasmaAunque en otras implementaciones la cabezadel ltimo objeto se aprovecha para incluir unultimo elemento aqu el final se marca con unobjeto fantasma con ambos atributos a null.Esto evita excepciones de puntero a null ysimplifica la algoritmia con la lista a un nicocaso base isEmpty ()

ListaLa lista es una secuenciade pares (primero, resto)acabada en un parfantasma




public class ListDynamic implements ListIF *{

private T first;private ListIF tail;

public ListDynamic (){

first = null;tail = null;

}

public ListDynamic (ListIF list){

this ();if (list != null)if (!list.isEmpty ()){first = list.getFirst ();tail = new ListDynamic (list.getTail ());

}}

@Overridepublic T getFirst (){

return first;}

Implementacin dinmica basada en primero y siguiente

@Overridepublic ListIF getTail (){

if (isEmpty ()) return this;return tail;

}

@Overridepublic ListIF insert (T element){

if (element != null) {ListDynamic next = new ListDynamic();next.first = first;next.tail = tail;first = element;tail = next;

} return this;

}

@Overridepublic boolean isEmpty (){

return first == null &&tail == null;

}

@Overridepublic boolean isFull () {

return false; }

Segn esta estrategia de implementacin, una lista esta formada por un atributo querepresenta la cabeza y otro que es una referencia a una lista que representa el resto de lalista. De esta manera una lista es una coleccin encadenada de pares (primero, resto).

* Los comentarios de las cabeceras sehan omitido por cuestiones de espacio




@Overridepublic int getLength () {

if (isEmpty ()) return 0;else return 1 + tail.getLength ();

}

@Overridepublic IteratorIF getIterator () {

ListIF handler = new ListDynamic (this);return new ListIterator (handler);

}

@Overridepublic boolean contains (T element) {

... }

@Overridepublic ListIF sort (ComparatorIF comparator) {

...}

@Overridepublic int hashcode () {return 31 * ((first == null) ? 0 : first.hashCode ())

+ ((tail == null) ? 0 : tail.hashCode ());}

Implementacin dinmica basada en primero y siguiente

@Overridepublic boolean equals (Object o){

if (o == this) return true;if (o == null) return false;

if (!(o instanceof ListDynamic)) return false;else {

ListDynamic l = (ListDynamic) o;return l.first.equals (first) &&

l.tail.equals (tail);}

}

@Overridepublic String toString (){

StringBuffer buff = new StringBuffer ();buff.append ("ListDynamic - [");

IteratorIF listIt = getIterator ();while (listIt.hasNext ()) {

T element = listIt.getNext ();buff.append (element);if (listIt.hasNext ())

buff.append (", ");}

buff.append ("]");return buff.toString ();

}

Segn esta estrategia de implementacin, una lista esta formada por un atributo querepresenta la cabeza y otro que es una referencia a una lista que representa el resto de lalista. De esta manera una lista es una coleccin encadenada de pares (primero, resto).





Implementacin del tipo abstracto de datos Lista ListIF

Existen varias estrategias para implementar listas que respondan al interfaz ListIF anterior.En general, stas se dividen en implementaciones dinmicas, que articulan listas decapacidad infinita e implementaciones estticas, con una capacidad mxima limitada yestablecida como parmetro. Aqu presentamos un ejemplo de cada caso

Implementacin esttica basada en arraySegn esta estrategia de implementacin, una lista est constituida por un array decapacidad limitada y especificada mediante parmetro y un ndice que apunta a la cabezade la lista. La lista empieza por el final y crece hacia la primera posicin del array

3 41 23 70 00 0

PrimeroEste ndice apunta siempreal elemento que seencuentra en cabeza de lalista. El ndice comienza en0 y llega hasta capacidad1para valores de la lista

InsertarLas inserciones mueven lacabeza una posicin hacia atrse insertan el elemento. SiPrimero llega a valer 0 la listaest llena y no se puede insertar

RestoAcceder al resto mueve lacabeza una posicin haciadelante con lo que sta pasa aser el primero del resto. SiPrimero llega a valer lacapacidad indica que la lista esvaca

ListaLa lista est formada por loselementos que van desde laposicin Primero hastacapacidad - 1

Capacidad = 10Basura

El resto de elementos delarray que no pertenecen a lalista es basura resultado deltrabajo con el tipo




public class ListStatic implements ListIF *{

private Object[] elements;private int capacity;private int first;

public ListStatic (int capacity){

this.capacity = capacity;this.first = capacity;this.elements = new Object[capacity];

}

public ListStatic (int capacity, ListIF list){

this (capacity);if (list != null) {

ListIF aList = list;for (int i = capacity-list.getLength (); i <

capacity ; i++) {this.elements [i] = aList.getFirst ();this.first = this.first - 1;aList = aList.getTail ();

} }

private ListIF copy (ListStatic list) { ListStatic l = new ListStatic (capacity);l.first = first;l.elements = elements;return l; }

Implementacin esttica basada en array

@SuppressWarnings("unchecked")@Overridepublic T getFirst (){

if (isEmpty ()) return null;return (T) elements [first];

}

@Overridepublic ListIF getTail (){

if (!isEmpty ()) {ListStatic tail = (ListStatic) copy (this);tail.first = first + 1;return tail;

}return this;

}

@Overridepublic ListIF insert (T element){

if (!isFull ()) {first = first - 1;elements [first] = element;

}return this;

}

Segn esta estrategia de implementacin, una lista est constituida por un array decapacidad limitada y especificada mediante parmetro y un ndice que apunta a la cabezade la lista. La lista empieza por el final y crece hacia la primera posicin del array





@Overridepublic boolean isEmpty (){

return first == capacity;}

@Overridepublic boolean isFull(){

return first == 0;}

@Overridepublic int getLength () {

return capacity - first;}

@Overridepublic IteratorIF getIterator (){

ListIF handler = new ListStatic (capacity, this);return new ListIterator (handler);

}

@Overridepublic boolean contains (T element) { ... }

@Overridepublic ListIF sort (ComparatorIF comparator) { ... }

Implementacin esttica basada en array

@Overridepublic int hashCode () {

return 31 * 31 * ((elements == null) ? 0 : elements.hashCode ()) +31 * capacity + first;

}

@SuppressWarnings("unchecked")@Overridepublic boolean equals (Object o) {

if (o == this) return true;if (o == null) return false;if (o.getClass () != this.getClass ()) return false;else { ListStatic l = (ListStatic) o;

return l.elements.equals (elements) &&l.capacity == capacity &&l.first == first; }

}

@Overridepublic String toString (){

StringBuffer buff = new StringBuffer ();buff.append ("ListStatic - ["); IteratorIF listIt = getIterator ();while (listIt.hasNext ()) {

T element = listIt.getNext ();buff.append (element);if (listIt.hasNext ())

buff.append (", ");}buff.append ("]");return buff.toString (); } }

Segn esta estrategia de implementacin, una lista est constituida por un array decapacidad limitada y especificada mediante parmetro y un ndice que apunta a la cabezade la lista. La lista empieza por el final y crece hacia la primera posicin del array






Estudiaremos 3 tipos de problemas recurrentes sobre la interfaz de listas ListIF: recorrido delos elementos de una lista, bsqueda de un elemento entre los elementos de una lista yordenacin ascendente de los elementos de una lista. La definicin recursiva del tipocondiciona las estrategias algortmicas que pueden utilizarse.


I. RecorridoEl recorrido de los elementos de una lista devuelve un iterador que permiteprocesarlos secuencialmente segn aparecen almacenados en la estructura.Como la definicin es recursiva solo el recorrido directo ser estudiado. Elrecorrido inverso es fcilmente implementable y se deja como ejercicio

II. BsquedaLa bsqueda de un elemento sobre los elementos de una lista se realiza deforma secuencial dada la definicin recursiva del tipo lo que imprime un costelineal al algoritmo. Se estudiar el predicado de contencin dejando comoejercicio la bsqueda del mnimo y el mximo

III. OrdenacinLa ordenacin de los elementos de una lista, reorganiza sus elementos deforma que se dispongan ascendentemente de acuerdo a cierto criterio decomparacin que se recibe como parmetro. En este captulo estudiaremosdos conocidos mtodos de ordenacin en listas: ordenacin por insercin(insert sort) y ordenacin por mezcla (merge sort).La ordenacindescendente es similar y se deja como ejercicio.

Independencia de la im

plementacin





Antes de pasar a discutir las estrategias de recorrido de los elementos de una lista debemospresentar el interfaz IteratorIF. Esta interfaz ser utilizada a lo largo del curso para articularel recorrido de los elementos de los diferentes tipos abstractos de datos que vayamosestudiando

La Interfaz IteratorIF

public interface IteratorIF{

/*** Devuelve el siguiente elemento de la iteracion. * @return el siguiente elemento de la iteracion.*/public T getNext ();

/*** Devuelve el siguiente elemento de la iteracion. * @return el siguiente elemento de la iteracion.*/public boolean hasNext ();

/*** Restablece el iterador para volver al inicio.*/public void reset ();

}

Devuelve el siguiente elemento dentro dela iteracin o null si el iterador alcanz elfinal

getNext ()

Este predicado indica si existen mselementos an sin visitar dentro de laiteracin

hasNext ()

Este mtodo, incluido por razones deeficiencia, permite resetear el iteradorpara que vuelva al principio sin que seanecesario construirlo de nuevo

reset ()





Para articular el recorrido secuencial de los elementos de una lista debe implementarse elinterfaz IteratorIF. Las implementaciones de ListIF anteriores construyen una copia de lalista como manejador para garantizar que la iteracin no modifique el estado del tipo

class ListIterator implements IteratorIF {

private ListIF handler;private ListIF restart;

/*** Constructor para ListIterator.* @param handler el manejador de listas.*/public ListIterator (ListIF handler){

this.handler = handler;this.restart = handler;

}

/*** Devuelve el siguiente elemento de la iteracion. * @return el siguiente elemento de la iteracion.*/@Overridepublic T getNext () {

T next = handler.getFirst ();handler = handler.getTail ();return next;

}

Se mantienen 2 manejadores constantemente,una para articular el recorrido de la lista. La otrasiempre apunta a la cabeza de la lista y se utilizapara implementar la operacin de reset deliterador

Iteracin con reset

La operacin de avance devuelve el elemento encabeza de la lista y actualiza el manejador derecorrido para que apunte a la cabeza del restode la lista. Para invocar esta operacin conseguridad hay que asegurarse de que elmanejador no apunta a la cola vaca

Avance

3 41 2

handler getNext()

restart





Para articular el recorrido secuencial de los elementos de una lista debe implementarse elinterfaz IteratorIF. Las implementaciones de ListIF anteriores construyen una copia de lalista como manejador para garantizar que la iteracin no modifique el estado del tipo

/*** Devuelve cierto si existen mas elementos a iterar.* @return cierto si existen mas elementos a iterar.*/@Overridepublic boolean hasNext () {

return !handler.isEmpty ();}

/*** Restablece el iterador para volver al inicio.*/@Overridepublic void reset () {

handler = restart;}

@Overridepublic int hashCode () { ... }

@Overridepublic boolean equals (Object o) { ... }

@Overridepublic String toString () {...}

}

Para saber si el iterador contiene ms elementos y portanto puede volver a invocarse la operacin de avance ono hay que preguntar si el manejador ha alcanzado el finalde la lista

Hay siguiente

Una vez que un iterador ha llegado a su fin slo se puedeconstruir otro iterador, lo cual es costoso ya que requiereuna nueva copia del tipo, o resetearlo a su valor inicial,Gracias a la copia del manejador que hicimos en elconstructor del iterados, esta operacin tiene un costeconstante

Reset

3 41 2

handler

reset()

restart

handler





La bsqueda de un dato sobre los elementos contenidos en una lista es un problema derecorrido secuencial que termina cuando se encuentra una cabeza que corresponde con eldato buscado. En este sentido puede aplicarse un algoritmo recursivo o aprovechar eliterador anterior para resolverlo iterativamente mediante bsqueda con centinela

Bsqueda iterativa con centinela

/*** Devuelve cierto si la lista contiene el elemento.* @param element El elemento buscado.* @return cierto si la lista contiene el elemento.*/@Overridepublic boolean contains (T element){

IteratorIF listIt = this.getIterator ();boolean found = false;while (!found && listIt.hasNext ()) {

T anElement = listIt.getNext ();found = anElement.equals (element);

}return found;

}

En la bsqueda con centinela se itera sobrela lista y se utiliza una guarda (centinela)para indicar el momento en que se haencontrado el elemento y la bsquedapuede parar

Bsqueda recursiva

/*** Devuelve cierto si la lista contiene el elemento.* @param element El elemento buscado.* @return cierto si la lista contiene el elemento.*/@Overridepublic boolean contains (T element){

if (isEmpty ()) return false;return first.equals (element) ||

tail.contains (element);}

En la bsqueda recursiva se comprueba si lacabeza se corresponde con el elementobuscado. Si es as el algoritmo terminadevolviendo cierto y si no, se recurre sobreel resto de la lista para buscar el elemento





Antes de discutir los algoritmos de ordenacin debemos presentar dos artefactos que sernutilizados a lo largo del curso en la ordenacin de tipos abstractos de datos. Como los tiposson genricos es necesario proporcionar una implementacin del criterio de orden quedebe aplicarse entre dos elementos cualesquiera del mismo tipo

La Interfaz ComparatorIF

public interface ComparatorIF{

public static int LESS = -1;public static int EQUAL = 0;public static int GREATER = 1;

/*** Compara dos elementos para indicar si el primero es* menor, igual o mayor que el segundo elemento.* @param e1 el primer elemento.* @param e2 el segundo elemento.* @return el orden de los elementos. */public int compare (T e1, T e2);

/*** Indica si un elemento es menor que otro. * @param e1 el primer elemento.* @param e2 el segundo elemento.* @return true si un elemento es menor que otro.*/public boolean isLess (T e1, T e2);

/*** Indica si un elemento es igual que otro. * @param e1 el primer elemento.* @param e2 el segundo elemento.* @return true si un elemento es igual que otro.*/public boolean isEqual (T e1, T e2);

/*** Indica si un elemento es mayor que otro. * @param e1 el primer elemento.* @param e2 el segundo elemento.* @return true si un elemento es mayor que otro.*/public boolean isGreater (T e1, T e2);

}

Tambin se utilizar una clase abstractaComparatorBase que implementa esta interfaz.En ella, el primer mtodo es abstracto y el restose implementa delegando en ste.





Los algoritmos de ordenacin que pueden aplicarse sobre listas, son relativamente pocos,en comparacin con los que pueden aplicarse sobre estructuras de indexacin. En concretonosotros discutiremos en este captulo la ordenacin por insercin y la ordenacin pormezcla

Ordenacin por insercin/*** Ordena los elementos de la lista.* @param comparator El comparador de elementos.* @return la lista ordenada.*/@Overridepublic ListIF sort (ComparatorIF comparator){

if (isEmpty ()) return this;else return ((ListDynamic) tail.sort (comparator))

.sortInsert (first, comparator);}

/*** Inserta un elemento en orden en una lista ordenada.* @param element El elemento a insertar* @param comparator El comparador de elementos.* @return la lista ordenada.*/private ListIF sortInsert (T element, ComparatorIF comparator){

if (isEmpty ()) return this.insert (element);else if (comparator.isLess (element, first))

return this.insert(element);else return ((ListDynamic) tail)

.sortInsert (element, comparator).insert (first);}

Se proporciona un comparador cuyaimplementacin codifica el criterio de orden entredos elementos de la lista

Comparator

Si la lista es vaca se devuelve sta. Sino, seordena el resto de la lista recursivamente y seinserta en ella el primer elemento en la posicinadecuada segn el criterio de orden

Ordenacin

Si la lista es vaca se devuelve. Sino, si elelemento es menor que el primero, se inserta porel principio. Sino, se inserta en el resto elelemento a insertar

Insercin en orden

3 25 7 3 7

5

2






Ordenacin por mezcla/*** Ordena los elementos de la lista.* @param element El comparador de elementos.* @return la lista ordenada.*/@Overridepublic ListIF sort (ComparatorIF comparator){

if (getLength () = middle) lRight.insert (element);index = index + 1;

}lLeft = lLeft.sort (comparator);lRight = lRight.sort (comparator);return sortMerge (lLeft, lRight, comparator);

}}

3 25 7

3 25 7

5 7 3 2

Durante la primera fase, el algoritmo dividerecursivamente el problema en subproblemas dela mitad de tamao. Este proceso requiererecorrer la lista y tiene un coste de complejidadlineal

I. Fase de divisin






Ordenacin por mezclaprivate ListIF sortMerge (ListIF lLeft,

ListIF lRight,ComparatorIF comparator)

{ListDynamic result = new ListDynamic (); while (lLeft.getLength () > 0 || lRight.getLength () > 0) {

if (lLeft.getLength () > 0 && lRight.getLength () > 0) {T eLeft = lLeft.getFirst ();T eRight = lRight.getFirst ();if (comparator.isGreater (eLeft, eRight)) {

result.append (eLeft);lLeft = lLeft.getTail ();

} else {result.append (eRight);lRight = lRight.getTail ();

}} else if (lLeft.getLength () > 0) {

T eLeft = lLeft.getFirst ();result.append (eLeft);lLeft = lLeft.getTail ();

} else if (lRight.getLength () > 0) {T eRight = lRight.getFirst ();result.append (eRight);lRight = lRight.getTail ();

}}return result;

}

5 72 3

2 35 7

5 7 3 2

Una vez alcanzado elementos atmicos, la fasede mezcla combina las soluciones ordenandocada subproblema por combinacin de suselementos. De esta forma, se obtiene, al final, elarray completamente ordenado

II. Fase de mezcla



Ejercicios

Ejercicios

Dado el carcter recursivo de la definicin del tipo abstracto de datos ListIF, la mayora dealgoritmos sobre listan tienen un planteamiento recursivo. A continuacin se presentan unacoleccin de problemas tpicos sobre listas para que se resuelvan de esta manera

Disee una funcin recursiva quecalcule el nmero de elementos quecontiene una lista

I. Longitud de una listaDisee una funcin recursiva quedetermine si un elemento pertenecea los elementos de una lista

II. PerteneceDisee una funcin que dada una listadetermine si una lista es sublista deotra dada de mayor tamao

III. Sublista

Disee una funcin recursivadevuelva el ltimo elemento de unalista

IV. ltimo elementoDisee una funcin recursiva queinserte un dato como ltimoelemento de una lista

V. Insertar al finalDisee una funcin recursiva quedevuelve la lista resultante deconcatenar dos listas

VI. Concatenar dos listas

Disee una funcin recursiva quedevuelva una lista con los elementoscolocados de forma inversa a otra

VII. Lista inversaDisee una funcin recursiva quedevuelva una lista que elimine laprimera aparicin de un elemento

VIII. Borrado de un elementoDisee una funcin que devuelva unalista donde se hayan eliminado todaslas apariciones de un elemento

IX. Borrar todos

Disee una funcin recursiva quedevuelva una sublista prefijo queprecede a un elemento dado

X. Lista prefijoDisee una funcin recursiva quedevuelva la lista sufijo que sucede aun elemento dado

XI. Lista sufijoDisee una funcin recursiva quedevuelva una lista con todos loselementos mayores a uno dado

XII. Lista mayores



Bibliografa

Bibliografa

Bibliografa bsica

Estructuras de datos en java. Weiss, Mark

Allen. Pearson Addison Wesley. ISBN

9788478290352



Bibliografa

Bibliografa

Bibliografa complementaria

Estructura de datos y algoritmos en java. A.

Drozdek. Thomsom. ISBN: 9706866116. 2007

Estructuras de datos con Java. J. Lewis, J.

Chase. Pearson Addison Wesley. ISBN 13:

9788420541914

Nmero de diapositiva 1Nmero de diapositiva 2Nmero de diapositiva 3Nmero de diapositiva 4Nmero de diapositiva 5Nmero de diapositiva 6Nmero de diapositiva 7Nmero de diapositiva 8Nmero de diapositiva 9Nmero de diapositiva 10Nmero de diapositiva 11Nmero de diapositiva 12Nmero de diapositiva 13Nmero de diapositiva 14Nmero de diapositiva 15Nmero de diapositiva 16Nmero de diapositiva 17Nmero de diapositiva 18Nmero de diapositiva 19Nmero de diapositiva 20Nmero de diapositiva 21Nmero de diapositiva 22Nmero de diapositiva 23Nmero de diapositiva 25Nmero de diapositiva 26

EPED.07.Tema4.Tiposabstractosdedatoslineales.listas

Documents

Transcript of EPED.07.Tema4.Tiposabstractosdedatoslineales.listas