Programación Profesional
Desde CERO
TAD LINKEDLIST Y SUS VARIANTES
CONTENIDO
Introducción .............................................................................................................................................2
Objetivo....................................................................................................................................................2
Implementando IntLinkedList ...................................................................................................................2
Pasándolo a lista doble .........................................................................................................................3
Nuevos ejercicios ......................................................................................................................................3
Ejercicio 1 .............................................................................................................................................3
Ejercicio 2 .............................................................................................................................................4
Lo que se pide y debes entregar ...............................................................................................................4
Restricciones ........................................................................................................................................4
Entrega .................................................................................................................................................4
Vladimir Rodríguez www.kaedusoft.edu.uy 2018 – Página 1
Programación Profesional
Desde CERO
INTRODUCCIÓN
"La formación en informática no puede convertir a nadie en experto
programador, de la misma forma que estudiar pinceles y pigmentos no puede
hacer a alguien un experto pintor"
Eric Raymond
La teoría es necesaria, es tu mapa, es entender lo que haces, para qué lo haces y qué utilidad te puede
dar. Pero la experiencia es algo insustituible. No serás buen/a programador/a a menos que dediques horas
y horas a leer e implementar código, a sufrir buscando errores que parecen indetectables y a irte a dormir
pensando que eso que quieres hacer no se puede hacer, solo para despertar a la mañana siguiente
dándote cuenta de que era estúpidamente fácil.
Si fueras a realizarte una cirugía al corazón, porque la necesitas ¿Querrías que la hiciera el cirujano recién
recibido, que conoce toda la teoría a la perfección, o que la hiciera el cirujano que tiene 5 años de
experiencia en ese tipo de operaciones? Ambos estudiaron lo mismo, pero estarás de acuerdo, en que el
que tiene 5 años de operaciones y cirugías prácticas, sabe más que el recién recibido porque ha aprendido
cosas que la universidad no puede enseñar.
OBJETIVO
En este punto el objetivo es que entiendas en profundidad el TAD Lista Encadenada junto a sus variantes.
IMPLEMENTANDO INTLINKEDLIST
Lo primero que debes hacer es crear una clase llamada IntLinkedList la cual contendrá elementos de tipo
AtomicInteger en sus nodos, implementando para ella las siguientes operaciones públicas:
➢ IntLinkedList(): Crea una lista vacía.
➢ void agregar(AtomicInteger): Agrega el elemento AtomicInteger pasado como
argumento.
➢ void agregar(int): Agrega el entero pasado como argumento como un AtomicInteger.
➢ boolean esVacia(): Indica si la lista es vacía o no, arrojando true o false respectivamente.
➢ int cantidad(): Indica la cantidad de elementos existentes en la lista, 0 (cero) si es vacía.
➢ boolean existe(AtomicInteger): Indica si el elemento AtomicInteger existe en la
lista. Lo que se busca es el objeto (utilizar equals para comparar), no su valor entero. Arroja true
si el objeto existe, false si no.
➢ boolean existeValor(AtomicInteger): Indica si existe en la lista el entero contenido
en el objeto AtomicInteger pasado como argumento, arrojando true en tal caso, false si no.
➢ boolean existeValor(int): Indica si existe en la lista algún elemento con el valor entero
pasado como argumento, arrojando true en tal caso, false si no.
➢ int ocurrencias(AtomicInteger): Indica la cantidad de ocurrencias del objeto.
➢ int ocurrencias(int): Indica la cantidad de ocurrencias del valor pasado.
➢ AtomicInteger getElemento(int): Busca en la lista el primer elemento que contenga el
valor dado, lo quita de ella y lo retorna. Si no se encuentra ninguno se retorna null.
➢ void quitar(AtomicInteger): Quita de la lista el elemento indicado si existe.
➢ AtomicInteger getNext(): Retorna el siguiente elemento de la lista y avanza el apuntador.
Si no hay siguiente elemento se retorna null. Elemento no es quitado de la lista.
➢ boolean hasNext(): Indica si hay un siguiente elemento por recorrer en la lista.
➢ void resetAdelante(): Reinicia el apuntador de la lista para recorrerla nuevamente.
Vladimir Rodríguez www.kaedusoft.edu.uy 2018 – Página 2
Programación Profesional
Desde CERO
PASÁNDOLO A LISTA DOBLE
Transformarás la implementación anterior en una lista doblemente encadenada agregando las siguientes
operaciones:
➢ AtomicInteger getPrev(): Retorna el anterior elemento de la lista y retrocede el
apuntador. Si no hay elemento anterior retorna null. El elemento no es quitado de la lista.
➢ boolean hasPrev(): Indica si hay un elemento anterior por recorrer en la lista.
➢ void resetAtras(): Reinicia el apuntador volviéndolo hacia el último elemento de la lista.
De este modo ahora la lista se puede recorrer tanto hacia adelante como hacia atrás.
NUEVOS EJERCICIOS
A continuación, se te proponen ejercicios nuevos que puedes implementar si deseas realmente comprender
a fondo el uso de las listas y practicar con punteros.
EJERCICIO 1
Definirás una lista encadenada de enteros llamada ListaEnteros, con las siguientes operaciones:
/* Retorna el último elemento, si la lista l es no vacía. */
int last();
/* Retorna el promedio de sus elementos, si la lista l es no vacía, en tal caso
retorna 0*/
double average();
/* Asumiendo que la lista está ordenada, inserta x ordenadamente. Si la lista no
está ordenada se insertará al final */
void insert(int x);
/* Indica si la lista está ordenada. Si el orden es decreciente se retornará -1,
si es creciente se retorna 1, y no está ordenada se retorna 0. Si todos los
valores de la lista fueran iguales, se asume como ordenada ascendentemente, lo
mismo si está vacía. */
int esOrdenada();
/* Inserta el elemento x al final de la lista. */
void snoc(int x);
/* Elimina la primera ocurrencia de x en la lista. */
void remove(int x);
/*Verifica si la lista l está incluida en la lista actual, es decir, si todos los
valores de l existen en la lista actual en el mismo orden en que están en l. */
void isIncluded(ListaEnteros l) : boolean;
/*Retorna una nueva lista, resultado de tomar los primeros i elementos de la
lista actual. La nueva lista no comparte memoria con la lista original, es
independiente. Si i<=0 se retorna una lista vacía. Si la lista no tiene tantos
elementos como indica i, se retornarán todos los que sean posibles. */
ListaEnteros take(int i);
/*Retorna una nueva lista, resultado de exlcuir los primeros i elementos de la
lista original. Si i>= que la cantidad de elementos en la lista, se retorna una
lista vacía. Si i <=0 también se retorna una lista vacía. Si la lista ya es vacía
se retorna una lista vacía como resultado. La lista resultado no comparte memoria
con la lista original, es independiente.*/
ListaEnteros drop(int i);
/*Une l y p de forma ordenada ascendentemente. Retorna una nueva lista que
es independiente de l y de p (no comparte memoria), quedando éstas intactas. */
Vladimir Rodríguez www.kaedusoft.edu.uy 2018 – Página 3
Programación Profesional
Desde CERO
static ListaEnteros merge(ListaEnteros l, ListaEnteros p);
/*Une l y p en el orden en que están, retornando la lista resultado, que
es independiente. Las listas l y p no son modificadas de ninguna manera.*/
static ListaEnteros append(ListaEnteros l, ListaEnteros p);
EJERCICIO 2
Define, al igual que el tipo del ejercicio 1, un tipo llamado ListaStrings, el cual será una lista doble
encadenada de String. Implementa todas las operaciones anteriores para este tipo de datos.
LO QUE SE PIDE Y DEBES ENTREGAR
Debes implementar todo lo solicitado en este documento y entregar los archivos con el código fuente que
has programado, obviamente, en Java, siguiendo las especificaciones dadas hasta ahora en el curso. Tu
trabajo será evaluado y corregido a fin de verificar que funciona correctamente.
RESTRICCIONES
Para este trabajo puedes usar todo lo dado en el curso hasta el momento, sin apoyarte en herramientas no
vistas, como podría ser el uso de genéricos, ArrayList, Iterable, Iterator, o cualquier otro
componente del JDK o de terceros.
ENTREGA
Este trabajo es obligatorio y debe ser entregado ya que será evaluado por un docente. Lo que debes entregar
son TODOS los archivos con el código fuente. Dependiendo de la plataforma en que hagas el curso será el
medio por el cual enviarás el archivo:
➢ KA EduSoft: En la lección donde se te presenta este proyecto tendrás la opción para subir el archivo
del código fuente.
➢ Udemy: Escribe un correo electrónico a bedelia@kaedusoft.edu.uy con el asunto EJERCICIOS
TAD_LinkedLIst Variantes [NOMBRE] [APELLIDO] en el cual adjuntarás el archivo con el código
fuente de tu trabajo.
Vladimir Rodríguez www.kaedusoft.edu.uy 2018 – Página 4
