Practica de Laboratorio 06

UNIVERSIDAD DE LAS FUERZAS ARMADAS – ESPE
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
DEPARTAMENTO DE CIENCIAS DE LA COMPUTACIÓN FECHA ÚLTIMA
REVISIÓN: 26/10/16
CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN
GUÍA PARA LAS PRÁCTICAS DE LABORATORIO, TALLER O CAMPO

PERIODO
ASIGNATURA: ESTRUCTURAS DE DATOS 201951 NIVEL: 4
LECTIVO:
DOCENTE: Armando Ortiz NRC: 4883 PRÁCTICA N°: 06
LABORATORIO DONDE SE DESARROLLARÁ LA
PRÁCTICA:
TEMA DE LA
Implementación de TDA lista doblemente enlazada
PRÁCTICA:
INTRODUCCIÓN:
Los TDA (Tipo de Datos Abstracto) nos permite modelar o simular modelos de estructuras para el
almacenamiento y manejo de datos. Las listas son TDA´s dinámicos utilizados ampliamente en el área de
programación. Se utilizan justamente como su nombre lo indica para almacenar información a modo de una
lista de elementos. Existen 3 tipos de listas enlazadas: simplemente enlazadas, doblemente enlazadas y
circulares Las listas simplemente enlazadas se componen de nodos donde cada nodo apunta o tiene la
información del siguiente nodo en la lista, el último nodo apunta a NULL. Las listas doblemente enlazadas
tienen nodos donde cada nodo tienen la información del nodo anterior y posterior y tanto el primero como
el último nodo apuntan a NULL. Las listas circulares son listas doblemente enlazadas en las que cambia el
apuntar a NULL, apuntando entre el primer y el último nodo de la lista, formando una estructura circular.
Para que esta estructura sea un TDA lista enlazada, debe tener unos operadores asociados que permitan la
manipulación de los datos que contiene. Los operadores básicos de una lista enlazada son:
Insertar: inserta un nodo con dato x en la lista, pudiendo realizarse esta inserción al principio o final de la
lista o bien en orden.
Eliminar: elimina un nodo de la lista, puede ser según la posición o por el dato.
Buscar: busca un elemento en la lista.
Localizar: obtiene la posición del nodo en la lista.
Vaciar: borra todos los elementos de la lista
OBJETIVOS:
Realizar práctica y análisis sobre la implementación de listas, mediante la implementación de las listas doblemente enlazadas, y con
la ayuda de los anteriores métodos ya resueltos de la lista simple, para tener un mejor manejo sobre lo métodos esenciales que tiene
cada lista.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
OBJETIVOS ESPECIFICOS
 Realizar las respectivas características principales de las clases Nodo,
 Crear las clases que se van a usar para la implementación de lista doblemente enlazada,
 Crear los métodos respectivos de cada lista, ya sea los principales de agregar, eliminar y buscar elemento.
 Hacer capturas de pantalla de las diferentes compilaciones.
MATERIALES:
REACTIVOS: N/A INSUMOS: N/A
EQUIPOS: Computador
MUESTRA: N/A
INSTRUCCIONES:
Implementación de listas enlazadas:

Tomando en cuenta la siguiente implementación de una lista simplemente enlazadas:
CLASE LISTA
package listasimplementeenlazada;
public class ListaSimple<T> {
//atributos
private Nodo<T> primero;
private Nodo<T> ultimo;
private int size;
//constructor
public ListaSimple() {
this.primero=null;
this.ultimo=null;
this.size=0;
}
//getter and setters
public Nodo getPrimero() {
return primero;
}
public void setPrimero(Nodo primero) {
this.primero = primero;
}
public Nodo getUltimo() {

return ultimo;
}
public void setUltimo(Nodo ultimo) {

this.ultimo = ultimo;
}
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
public int getSize() {

return size;
}
public void setSize(int size) {

this.size = size;
}
//funciones propias
public int Size(){
return this.size;
}
public boolean isEmpty(){

return size==0;
}
public void add(T elemento){

Nodo<T> aux=new Nodo<>(elemento);
if(size==0){
this.primero=aux;
this.ultimo=aux;
} else {
this.ultimo.setSiguiente(aux);
this.ultimo=aux;
}
this.size++;
}
public int find(T elemento){

Nodo<T> aux=primero;
int pos=-1;
for(int i=0; i<size; i++){
if(aux.getDato().equals(elemento)){
return pos=i;
}else{
aux=aux.getSiguiente();
}
}
return pos;
}
public void delete(int pos){

if(size==1){
primero=null;
ultimo=null;
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
}else{
if(pos==size-1){
Nodo<T> ant=getNodo(pos-1);
ant.setSiguiente(null);
this.ultimo=ant;
}
if(pos==0){
Nodo<T> sig=getNodo(1);
this.primero.setSiguiente(null);
this.primero=sig;
}
if(pos>=1&& pos<size-1){
Nodo<T> ant=getNodo(pos-1);
Nodo<T> sig=getNodo(pos+1);
ant.setSiguiente(sig);
}
}
this.size--;
}
public Nodo<T> getNodo(int pos){
if(pos>=0&&pos<size){
for(int i=0;i<pos;i++){
}
return aux;
}else{
return null;
}
}
public boolean modify(T vBuscar,T vRemplazo){
int pos=find(vBuscar);
if(pos!=-1){
Nodo<T> nodo=getNodo(pos);
nodo.setDato(vRemplazo);
return true;
} else {
return false;
}
}
@Override
public String toString() {
if(size>0){
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
return primero.toString();
} else{
return "la lista esta vacia";
}
}
}
Analizar e implementar una lista doblemente enlazada

ACTIVIDADES POR DESARROLLAR:
Clase NODO
En la clase Nodo, debemos tomar en cuenta el dato, agregar el mismo tipo de nodo un siguiente y un anterior, esto es muy
importante al momento de usar lista doblemente enlazada.
Como en cualquier practica se crean los meotodos getts y setts de acuerdo a los atributos.
Ahora el método que se va a imprimir los datos del nodo en el que se va a almacenar, en este caso tendremos el dato anterior, el
dato del nodo y el dato del siguiente nodo.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
CLASE LISTA
METODOS SETTS Y GETTS
En el siguiente elemento de isEmpty, nos mostrara si la lista esta vacía y nos retornara verdadero en caso de que esta este vacía
y falso en caso de que si se encuentre elementos.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
METODOS LISTA DOBLEMENTE ENLAZADA

METODO AGREGAR ELEMETO
Para el siguiente método se trata el de agregar.
 Entonces desea ingresar al ultimo
 Si es que no hay nadie ocupando la posición final
 Entonces desea ingresar al inicio
 Si es que no hay nadie ocupando la posición inicial
METODO AGREGAR UN ELEMENTO ESPECIFICO EN UNA POSICION

 Extraemos el dato del valor que moveremos.
 Ubicamos el valor en la posición que le corresponde.
 Hacemos que el inicio de nuestro nuevo valor apunte a su anterior
 Hacemos que el fin de nuestro nuevo valor apunte a su posterior (el que movimos)
 Finalmente, al que movimos le asignamos que su anterior es el valor que lo remplazo
METODO ELIMINAR UN ELEMENTO

CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
Como parametro tendremos el elemento que se desea eliminar, entonces se obtiene el dato del siguiente elemento,
y lo guarda en el primero, mientras que el anterior eliminado a ese se cada como null.
METODO ELIMINAR UN ELEMENTO ESPECIFICO EN UNA POSICION
METODO MOSTRAR LISTA

Para la muestra de la lista, primero tenemos que realizar un control donde se compara el tamaño de la lista, para revisar si esta
está vacía o no.
Entonces obtenemos el dato anterior, caso serio null, se lo coloca el dato actual al primero. En caso de que el dato sea igual a null.
Ahora mientras que el dato sea diferente a null se mostrara los datos.
METODO MODIFICAR
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
Para el método de modificar tomamos en cuenta que tenemos dos parámetros el dato que se desea remplazar y el dato que va a
remplazar el elemento.
Para eso primero tenemos que buscar el dato dentro de la lista, una vez encontrado solo se le asigna el dato que deseamos a ese
elemento.
De igual manera la posición en la que se encuentra dicho dato no debe ser diferente de -1, es decir que dato al que se remplaza si
debe existir, caso contrario no se remplazaría por nada.
RESULTADOS OBTENIDOS:
Se realizaron los métodos principales de cada lista, y se obtuvo como resultado la lista de elementos
implementados ya los métodos esenciales.
Para mostrar los datos de los elementos ingresados en nuestros nodos debemos crear una clase que nos
actúe como MAIN, en este caso la llamaremos clase ListaDoblementeEnlazada.
Esta clase actuara únicamente como main, en la cual debemos crear una variable que llame a los métodos
creados en la otra clase, en esta se agregaran dos elementos, 20 en la posición 1, y el elemento 9 y 8 en la
posición 2.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
También se mostrarán si la lista está vacía isEmpty y cuantos elementos contiene Size.
Para buscar los datos tenemos que usar el método Find e ingresar el elemento que queramos buscar y
continuación se mostrara la posición en la que está.
Ahora usamos el método addAgregarEspecifica en la cual tiene dos parámetros en elemento que haya que
ingresar y la posición en la que se quiere que encuentre.
Ahora para comprobar, tenemos que volver a preguntar sobre las posiciones de los elementos.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
Ahora usaremos el método EliminarDato el cual tiene como parámetro de ingreso el elemento que se
desea eliminar. Una vez eliminada el elemento, volvemos a mostrar la lista para verificar si se elimino
correctamente.
Ahora tendremos que usar el método modificarElemento el cual tendrá como parámetro el elmento que
deseamos a modificar y el elemento que se desea remplazar, de igual manera tenemos que mostrar la lista
para ver si el método funciona correctamente.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
CONCLUSIONES:
En conclusión, la práctica de laboratorio se la realizo con éxito. Ya que las listas enlazadas nos permiten
almacenar datos de una forma organizada, también es una estructura TDA dinámica lo cual quiere decir que
es una estructura de tipo de datos abstracto.
Cada nodo de la lista doblemente enlazada contiene dos punteros de forma que uno apunta al siguiente
nodo y el otro predecesor permite que se pueda recorrer la lista en ambos sentidos.
La lista doblemente enlazada es que el enlace anterior al primer nodo apunta al último y el enlace siguiente
al último nodo, apunta al primero. Y las inserciones y eliminación pueden ser realizadas desde cualquier
punto en acceso al nodo más cercano.
Las listas enlazadas permiten almacenar información en posiciones de memoria que no sean contiguas;
para almacenar la información contienen elementos llamados nodos. Estos nodos poseen dos campos uno
para almacenar la información o valor del elemento y otro para el enlace que determina la posición del
siguiente elemento o nodo de la lista.
RECOMENDACIONES:
 Tomar en cuenta los métodos que se van a implementar de acuerdo a la lista doblemente enlazada
ya que, a comparación de lista simple, este añade un atributo más al nodo, el cual es el dato
anterior.
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
 Realizar los métodos de la forma correcta de acuerdo a lo que se determine el concepto sobre lista
doblemente enlazada y tener en cuenta cada característica que pide este tipo de lista nueva a
implementar.
ANEXO
CODIGO
CLASE Main_Lista
public class Main_Lista {
public static void main(String[] args) {
Lista_Doblemente_Enlazada element=new Lista_Doblemente_Enlazada();
element.addAgregar(20, 1);
System.out.println("Lista vacia: "+element.isEmpty());
System.out.println("Cuantos elementos: "+element.Size());
System.out.println("El elemento 9 esta en la poicion: "+element.buscarElemento(9));
System.out.println("\n Los elementos agregados son:");
element.VerLista();
System.out.println("\n Se agrega el elemento 15 en 1");
element.addAgregarEspecifica(15, 1);
element.VerLista();
System.out.println("\n Ahora vemos las nuevas posiciones");
System.out.println("El elemento 20 elimnado de la lista ");
element.EliminarDato(20);
element.VerLista();
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
System.out.println("\nEl elemento modificado ");

element.modificarElemento(9 , 11);
element.VerLista();
System.out.println("\n Cuantos elementos actualmente: "+element.Size());
}
}
CLASE Main_Lista
public class Lista_Doblemente_Enlazada<T> {
//Atributos
private Nodo primero;
private Nodo ultimo;
private int size;
// Contructor
public Lista_Doblemente_Enlazada(){
this.primero=null;
this.ultimo=null;
this.size=0;
}
// Getters and Setters

public Nodo getPrimero() {
return primero;
}
public void setPrimero(Nodo primero) {

CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
this.primero = primero;
}
public Nodo getUltimo() {

return ultimo;
}
public void setUltimo(Nodo ultimo) {

this.ultimo = ultimo;
}
public int getSize() {

return size;
}
public void setSize(int size) {

this.size = size;
}
//Funciones propias
public int Size(){
return this.size;
}
//--------------------------------------------------------------
public boolean isEmpty(){
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
return size==0;
}
/**
* @param elemento
* @param iniofin 1 para el inicio y 2 para final
*/
public void addAgregar(T elemento, int dato){
Nodo<T> aux=new Nodo<T>(elemento);
Nodo<T> casoFinal=primero;
if(size==0){
primero=aux;
ultimo=aux;
}
else{
//Entonces desea ingresar al ultimo
if(dato==2){
//Si es que no hay nadie ocupando la posición final
if(primero==null){
primero = aux;
}
else{
while(casoFinal.getSiguiente() != null){
casoFinal = casoFinal.getSiguiente();
}
casoFinal.setSiguiente(aux);
aux.setAnterior(casoFinal);
}
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
}
//Entonces desea ingresar al inicio
if(dato==1)
{
//Si es que no hay nadie ocupando la posición inicial
if(primero==null){
primero = aux;
}
else{
aux.setSiguiente(primero);
primero.setAnterior(aux);
primero = aux;
}
}
}
this.size++;
}
public void addAgregarEspecifica(T elemento, int pos){

Nodo<T> aux=new Nodo<T>(elemento);
if(pos == 1){
addAgregar(elemento, 1);
return;
}
Nodo<T> pri = primero;
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
for( int i = 2; i<=size ; i++){

if (i == pos){
Nodo sigue = pri.getSiguiente();
pri.setSiguiente(aux);
aux.setAnterior(pri);
aux.setSiguiente(sigue);
sigue.setAnterior(aux);
}
pri = pri.getSiguiente();
}
this.size++;
}
public void EliminarDato(T elemento){

if(primero != null){
Nodo<T> aux = primero;
Nodo<T> des = null;
while(aux != null){
if (aux.getDato() == elemento ){
if (des == null){
primero = primero.getSiguiente();
aux.setSiguiente(null);
aux= primero;
}else {
des.setSiguiente(aux.getSiguiente());
aux.setSiguiente(null);
aux = des.getSiguiente();
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
}
}else{
des = aux;
aux = aux.getSiguiente();
}
}
}
this.size--;
}
public int buscarElemento(T elemento){

int pos=-1;
for(int i=0;i<size;i++){
if(aux.getDato().equals(elemento)){
return pos=i;
}
else{
}
}
return pos;
}
public void VerLista()
{
Nodo<T> ptr = primero;
if (size == 0)
CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
{
System.out.print("NO HAY NADA");
return;
}
System.out.print("[" + ptr.getAnterior() +", "+ primero.getDato()+ " , ");
ptr = primero.getSiguiente();
while (ptr.getSiguiente() != null)
{
System.out.print(ptr.getDato()+ " , ");
ptr = ptr.getSiguiente();
}
System.out.print(ptr.getDato()+ "," + ptr.getSiguiente() + "] ");
}
public Nodo<T> getNodo(int pos){

if(pos>=0&&pos<size){
for(int i=0;i<pos;i++){
}
return aux;
}else{
return null;
}
}
public boolean modificarElemento(T vBuscar,T vRemplazo){

CÓDIGO: SGC.DI.505
VERSIÓN: 1.0
REVISIÓN: 26/10/16
int pos=buscarElemento(vBuscar);
if(pos!=-1){
Nodo<T> nodo=getNodo(pos);
nodo.setDato(vRemplazo);
return true;
} else {
return false;
}
}
FIRMAS
F: …………………………………………. F: …………………………………………. F: ……………………………………………..

Nombre: Armando Ortiz Nombre: Margoth Guaraca: Nombre:
COORDINADOR DE ÁREA DE COORDINADOR DE LABORATORIOS
DOCENTE CONOCIMIENTO
CODIGO

Practica de Laboratorio 06

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Practica de Laboratorio 06

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD DE LAS FUERZAS ARMADAS – ESPE

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

GUÍA PARA LAS PRÁCTICAS DE LABORATORIO, TALLER O CAMPO

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

REACTIVOS: N/A INSUMOS: N/A

Implementación de listas enlazadas:

public Nodo getUltimo() {

public void setUltimo(Nodo ultimo) {

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

public int getSize() {

public void setSize(int size) {

public boolean isEmpty(){

public void add(T elemento){

public int find(T elemento){

public void delete(int pos){

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

Analizar e implementar una lista doblemente enlazada

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

METODOS SETTS Y GETTS

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

METODOS LISTA DOBLEMENTE ENLAZADA

METODO AGREGAR UN ELEMENTO ESPECIFICO EN UNA POSICION

METODO ELIMINAR UN ELEMENTO

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

METODO ELIMINAR UN ELEMENTO ESPECIFICO EN UNA POSICION

METODO MOSTRAR LISTA

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

System.out.println("\nEl elemento modificado ");

// Getters and Setters

public void setPrimero(Nodo primero) {

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

public Nodo getUltimo() {

public void setUltimo(Nodo ultimo) {

public int getSize() {

public void setSize(int size) {

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

public void addAgregarEspecifica(T elemento, int pos){

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

for( int i = 2; i<=size ; i++){

public void EliminarDato(T elemento){

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

public int buscarElemento(T elemento){

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

public Nodo<T> getNodo(int pos){

public boolean modificarElemento(T vBuscar,T vRemplazo){

CARRERA: INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

F: …………………………………………. F: …………………………………………. F: ……………………………………………..

You might also like