Se ha denunciado esta presentación.
Se está descargando tu SlideShare. ×

Algoritmos y Estructura de datos_Semana5 (3).ppt

Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio

Eche un vistazo a continuación

1 de 50 Anuncio
Anuncio

Más Contenido Relacionado

Más reciente (20)

Anuncio

Algoritmos y Estructura de datos_Semana5 (3).ppt

  1. 1. UNIVERSIDADTÉCNICADEMANABÍ DEPARTAMENTODETECNOLOGÍAS DELAINFORMACIÓNYLA COMUNICACIÓN ALGORITMOS Y ESTRUCTURAS DE DATOS Por Christian Torres. UNIDAD II
  2. 2. WOODGROVE BANK U2-TEMA 3 ARREGLOS 2 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  3. 3. ARREGLOS  Una array o arreglo es una colección de variables del mismo tipo, a la que se hace referencia por un nombre común. En Java, los arrays pueden tener una o más dimensiones, aunque el array unidimensional es el más común..  Los arrays se usan para una variedad de propósitos porque ofrecen un medio conveniente de agrupar variables relacionadas. Por ejemplo, puede usar una matriz para mantener un registro de la temperatura alta diaria durante un mes, una lista de promedios de precios de acciones o una lista de tu colección de libros de programación  La ventaja principal de un array es que organiza los datos de tal manera que puede ser manipulado fácilmente. Por ejemplo, si tiene un array que contiene los ingresos de un grupo seleccionado de hogares, es fácil calcular el ingreso promedio haciendo un ciclo a través del array. Además, los arrays organizan los datos de tal manera que se pueden ordenar fácilmente.  Aunque los arrays en Java se pueden usar como matrices en otros lenguajes de programación, tienen un atributo especial: se implementan como objetos. Este hecho es una de las razones por las que la discusión de los arrays se pospuso hasta que se introdujeron los objetos. Al implementar arrays como objetos, se obtienen varias ventajas importantes, una de las cuales es que los arrays no utilizados pueden ser recolectados. 3 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  4. 4. ARRAYSUNIDIMENSIONALES  Un array unidimensional es una lista de variables relacionadas. Tales listas son comunes en la programación. Por ejemplo, puede usar un array unidimensional para almacenar los números de cuenta de los usuarios activos en una red. Otro array podría usarse para almacenar los promedios de bateo actuales para un equipo de béisbol.  La forma general de declarar un arreglo unidimensional es: tipo nombre-array[]; O tipo [] nombre-array;  La declaración de un array tiene dos componentes: el tipo y el nombre.  El tipo de elemento determina el tipo de datos de cada elemento que comprende la matriz. Al igual que la matriz de tipo int, también podemos crear una matriz de otros tipos de datos primitivos como char, float, double..etc o tipo de datos definido por el usuario (objetos de una clase). Por lo tanto, el tipo de elemento para la matriz determina el tipo de datos que la matriz contendrá. 4 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  5. 5. ARRAYSUNIDIMENSIONALES  Aunque la primera declaración anterior establece el hecho de que intArray es una variable de matriz, en realidad no existe una matriz. Simplemente le dice al compilador que esta variable (intArray) contendrá una matriz del tipo entero. Para vincular intArray con una matriz física real de enteros, debe asignar una usando new y asignarlo a intArray. 5 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  6. 6. ARRAYSUNIDIMENSIONALES Instanciando un array en Java Cuando un array se declara, solo se crea una referencia del array. Para realmente crear o dar memoria al array (a partir de aquí solo mencionaré a array, y no matriz o arreglo), puede crear un array de la siguiente manera: nombre-array = new tipo [tamaño]; •tipo especifica el tipo de datos que se asignará •tamaño especifica el número de elementos en el array •nombre-array es el nombre de la variable del array vinculado al mismo. •Es decir, para usar new para asignar un array, debe especificar el tipo y la cantidad de elementos a asignar. Ejemplo: int intArray[]; //declarando un array intArray = new int[20]; // asignando memoria al array O int[] intArray = new int[20]; // combinando ambas declaraciones en una Nota: •Los elementos en la matriz asignada por new se inicializarán automáticamente a cero (para tipos numéricos), false (para booleano) o null (para tipos de referencia). •Obtener un array es un proceso de dos pasos. Primero, debe declarar una variable del tipo de array deseado. En segundo lugar, debe asignar la memoria que mantendrá el array, usar new y asignarla a la variable del array. Por lo tanto, en Java, todos los arrays se asignan dinámicamente. 6 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  7. 7. ARRAYSUNIDIMENSIONALES Array Literal  En una situación en la que ya se conoce el tamaño y los elementos del array, se pueden usar literales del array. int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; // Declarando un array literal •La longitud de este array determina la longitud del array creado. •No es necesario escribir new int[] en las últimas versiones de Java  Accediendo a los elementos del Array usando el bucle for A cada elemento del array se accede a través de su índice. El índice comienza con 0 y termina en (tamaño total del array) -1. Se puede acceder a todos los elementos de la matriz usando el bucle for en Java. //acceder a los elementos del array for (int i = 0; i < arr.length; i++) System.out.println("Elemento en el índice " + i + " : "+ arr[i]); 7 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  8. 8. ARRAYSUNIDIMENSIONALES Nota: También puede acceder a los arrays de Java utilizando el bucle for-each 8 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  9. 9. ARRAYSUNIDIMENSIONALES Arrays de objetos  Se crea una matriz de objetos como una matriz de elementos de datos de tipo primitivo de la siguiente manera. //student es una clase definida por el usuario Student[] arr = new Student[7];  El array Student contiene siete espacios de memoria, cada uno del tamaño de la clase Student, en los que se puede almacenar la dirección de siete objetos de Student.  Los objetos de Student deben crearse con el constructor de la clase Student. ¿Qué sucede si tratamos de acceder al elemento fuera del tamaño del array? El compilador arroja ArrayIndexOutOfBoundsException para indicar que se ha accedido al array con un índice ilegal. El índice es negativo, mayor o igual que el tamaño del array. 9 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  10. 10. ARRAYSMULTIDIMENSIONALES  Las matrices multidimensionales son matrices de matrices o arrays de arrays, donde cada elemento del array contiene la referencia de otro array. Se crea una matriz multidimensional al agregar un conjunto de corchetes ([]) por dimensión. Ejemplos: int[][] intArray = new int[10][20]; //un array 2D o matrix int[][][] intArray = new int[10][20][10]; //una array 3D 10 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  11. 11. ARRAYS Pasar arrays a métodos  Al igual que las variables, también podemos pasar arrays a los métodos.  Por ejemplo, en el programa siguiente se pasa un array al método sum para calcular la suma de los valores del array Retornando arrays de métodos  Como de costumbre, un método también puede devolver un array. Por ejemplo, en el siguiente programa se devuelve (return) un array desde el método m1. 11 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  12. 12. ARRAYS Objectos Class para arrays  Cada array tiene un objeto Class asociado, compartido con todos los demás arrays con el mismo tipo de componente. La cadena “[I” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type int”. La única superclase directa de cualquier tipo de array es java.lang.Object. La cadena “[B” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type byte”. La cadena “[S” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type short”. La cadena “[L” es la firma de tipo de tiempo de ejecución para el objeto class “array with component type of a Class”. El nombre de la clase es seguido. Explicación: 12 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  13. 13. ARRAYS Miembros del Array  Los arrays son objetos de una clase y la superclase directa de los arrays es la clase Object.  Los miembros de un tipo de array son todos los siguientes: •length, que contiene la cantidad de componentes del array, puede ser positiva o cero. •Todos los miembros son heredados de la clase Object; el único método de Object que no se hereda es su método de clone. •El método público clone(), anula el método de clonación en la clase Object y no arroja excepciones. Arrays irregulares  Cuando asigna memoria para un array multidimensional, necesita especificar solo la memoria para la primera dimensión (más a la izquierda). Puede asignar las dimensiones restantes por separado. Por ejemplo, el siguiente código asigna memoria para la primera dimensión de la tabla cuando se declara. Asigna la segunda dimensión de forma manual. int tabla[][]= new int [3][] tabla[0] = new int [4] tabla[1] = new int [4] tabla[2] = new int [4] Aunque no hay ninguna ventaja en la asignación individual de los arrays de segunda dimensión en esta situación, puede haber otras. Por ejemplo, cuando asigna por separado, no necesita asignar la misma cantidad de elementos para cada índice. Como las matrices multidimensionales se implementan como arrays de arrays, la longitud de cada array está bajo su control. 13 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  14. 14. ARRAYS  Por ejemplo, suponga que está escribiendo un programa que almacena el número de cursos en una universidad. Suponga que existen 10 cursos al día durante la semana y dos cursos al día los sábados y domingos, puede usar el array Cursos que se muestra en el siguiente programa para almacenar la información. Observe que la longitud de la segunda dimensión para los primeros cinco índices es 10 y la longitud de la segunda dimensión para los dos últimos índices es 2. El uso de matrices multidimensionales irregulares (o desiguales) no se recomienda para la mayoría de las aplicaciones, ya que funciona de manera contraria a lo que la gente espera encontrar cuando se encuentra una matriz multidimensional. Sin embargo, las matrices irregulares se pueden usar eficazmente en algunas situaciones. Por ejemplo, si necesita una matriz bidimensional muy grande que está escasamente poblada (es decir, una en la que no se usarán todos los elementos), una matriz irregular podría ser una solución perfecta. 14 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  15. 15. ARRAYS  Al igual que con otros objetos, cuando asigna una variable de referencia de un array a otra, simplemente está cambiando a qué objeto se refiere dicha variable. No está causando que se realice una copia del array, ni hace que el contenido de un array se copie en la otra. Por ejemplo, considere este programa: Asignación de referencias en Arrays Como muestra en el resultado, después de la asignación de nums1 a nums2, ambas variables de referencia del array se refieren al mismo objeto. 15 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  16. 16. ARRAYS  Cuando clona un array dimensional único, como Object[], se realiza una “copia profunda” con el nuevo array que contiene copias de los elementos del array original en lugar de referencias. Clonación de arrays  Sin embargo, un clon de una matriz multidimensional (como Object [] []) es una “copia superficial”, lo que quiere decir que crea solo un nuevo array con cada array de elementos como referencia a un array de elementos original, pero los subcampos se comparten. 16 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  17. 17. ARRAYS  Debido a que los arreglos se implementan como objetos, cada array tiene asociado una variable de instancia de longitud (length) que contiene la cantidad de elementos que el array puede contener. (En otras palabras, length contiene el tamaño del array.) Aquí hay un programa que demuestra esta propiedad: Uso de length en Arrays 17 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  18. 18. ARREGLOSDINÁMICOS  Java permite incluir la clase ArrayList en sus programas, es una clase que permite almacenar datos en memoria de forma similar a los Arrays, con la ventaja de que el numero de elementos que almacena, lo hace de forma dinámica, es decir, que no es necesario declarar su tamaño.  los ArrayList nos permiten añadir, eliminar y modificar elementos (que pueden ser objetos o elementos atómicos) de forma trasparente para el programador.  La clase ArrayList puede ser utilizada al incluir la biblioteca java.util.  Esta herramienta permite crear arreglos con elementos con tipos de datos primarios o utlilizando objetos definidos por el programador: // Por ejemplo, la siguiente declaración de un ArrayList es de tipo "String“ la sintaxis sería la siguiente: ArrayList<String> nombreArrayList = new ArrayList<String>(); 18 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  19. 19. ARREGLOSDINÁMICOS //Para crear un ArrayList de tipo Empleado se aplica la siguiente sintaxis: ArrayList<Empleado> listaEmpleados = new ArrayList< Empleado >(); Class Empleado{ private String nombre; private String apellido; private int edad; private double salario; public Empleado(String nombre, String apellido, int edad, double salario){ this.nombre=nombre; this.apellido = apellido; this.edad = edad; this.salario = salario; } public String dameDatos(){ return “El empleado: ”+ nombre + “ ” + apellido+ “, tiene:” + edad + “años, gana:” + salario; } }  Para ejemplificar el uso de ArrayList utilizando objetos, considere la clase Empleado MÉTODOS PARÁMETROS DESCRIPCIÓN add Elemento a insertar. Añade un elemento al final. remove Índice a borrar. Borra un elemento clear Ninguno Limpia el ArrayList de elementos. size Ninguno Devuelve el número de elementos get Índice del elemento a extraer Devuelve el elemento indicado isEmpty Ninguno Indica si el ArrayList esta vacía La herramienta posee varios métodos que permiten gestionar los datos, por ejemplo: 19 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  20. 20. ARREGLOSDINÁMICOS //Recordemos que para llenar los objetos sería por cada posición: arrayEmpleados[0]=new Empleado(“Ana", “Macias", 23, 1000); arrayEmpleados[1]=new Empleado(“Yoly", “Paez", 30, 1500); arrayEmpleados[2]=new Empleado(“Juan", “Bravo", 25, 1200); //Aquí se llenan los datos sin la necesidad de especificar la ubicación específica de los objetos: listaEmpleados.Add(new Empleado(“Ana", “Macias", 23, 1000)); listaEmpleados.Add(new Empleado(“Yoly", “Paez", 30, 1500)); listaEmpleados.Add(new Empleado(“Juan", “Bravo", 25, 1200)); Recuerde que los arreglos estáticos están limitados en cuanto al número de elementos que puede almacenar, los arreglos dinámicos que implementa Java permite ampliar la capacidad de almacenamiento en tiempo de ejecución, funciona de la siguiente forma: //Creamos un array estático de 3 objetos de la clase Empleado Empleado arrayEmpleados[]=new Empleado[3]; //Ahora creamos un ArrayList (arreglo dinámico) de objetos de la clase Empleado ArrayList<Empleado> listaEmpleados = new ArrayList<Empleado>(); //También es posible crear y al mismo tiempo llenarlos conforme a la posición de la misma forma que un arreglo estático: listaEmpleados.set(0,new Empleado(“Ana", “Macias", 23, 1000)); listaEmpleados.set(1,new Empleado(“Yoly", “Paez", 30, 1500)); listaEmpleados.set(2,new Empleado(“Juan", “Bravo", 25, 1200)); 20 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  21. 21. ARREGLOSDINÁMICOS //Para obtener datos desde un arreglo estático: System.out.println(arrayEmpleados[2].dameDatos()); //Para obtener datos desde un arreglo dinámico: System.out.println(listaEmpleados.get(2).dameDatos()); //Se puede recorrer un arreglo estático de la siguiente forma for (int i=0;i<arrayEmpleados.length;i++){ System.out.println(arrayEmpleados[i].dameDatos()); } //Se puede recorrer un arreglo dinámico de la siguiente forma for (int i=0;i< listaEmpleados.size();i++){ Empleado e= listaEmpleados.get(i); System.out.println(e.dameDatos()); } //Este un ejemplo mejorado de recorrido de una estructura: for (Empleado e: listaEmpleados){ System.out.println(e.dameDatos()); } EL FOR EXTENDIDO O BUCLES FOR EACH EN JAVA Esta forma de uso del for() existe en otros lenguajes, facilita el recorrido de objetos existentes en una colección sin necesidad de definir el número de elementos a recorrer. for (TipoARecorrer nombreVariableTemp : nombreDeLaColección ) { Instrucciones } A la hora de obtener datos contenidos en el arreglo se puede diferenciar entre la estructura estática y la estructura dinámica: Para recorrer la estructura estática y la estructura dinámica se puede aplicar lo siguiente: FORMATO: 21 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  22. 22. WOODGROVE BANK U2-TEMA4 LISTAS SIMPLEMENTE ENLAZADAS 2 22 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  23. 23. ESTRUCTURASDEDATOSLINEALES  Una estructura de almacenamiento lineal, es una colección de elementos (denominados nodos) secuencialmente dispuestos uno a continuación de otro, con la finalidad de que cada uno de ellos sirva de conexión al siguiente mediante un “enlace” o “referencia”, por ejemplo:  La idea básica consiste en construir una lista cuyos elementos, llamados nodos, se componen de dos partes (campos): la primera parte contiene la información, un valor de un tipo genérico (denominado Dato, TipoElemento, Info, etc.), y la segunda parte es una referencia (denominado enlace o sgte) que apunta (enlaza) al siguiente elemento de la lista. La representación gráfica más extendida es aquella que utiliza una caja (un rectángulo) con dos secciones en su interior. Representación gráfica del último nodo de la estructura  Las listas enlazadas son estructuras muy flexibles y con numerosas aplicaciones en el mundo de la programación Esta materia se basa en el análisis, diseño y creación de estructuras dinámicas donde el estudiante podrá conocer y aplicar los diferentes algoritmos propuestos para administrar grandes volúmenes de información, el ArrayList y otras estructuras dinámicas que ofrece Java son transparentes para el usuario y no cumplen con el objetivo principal de la materia; en este capítulo se desarrollarán métodos para insertar, buscar y borrar elementos en un estructura lineal. 23 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  24. 24. ESTRUCTURASDEDATOSLINEALES  Lista circular doblemente enlazada. Una lista doblemente enlazada en la que el último elemento se enlaza al primer elemento y viceversa. Esta lista se puede recorrer de modo circular (“en anillo”) tanto en dirección directa (“adelante”) como inversa (“atrás”). Una de las estructuras dinámicas de mayor notoriedad para el aprendizaje son las estructuras lineales, se caracterizan por tener una secuencia unidireccional de elementos, un elemento de la estructura apunta o referencia a la siguiente y/o a la anterior, por la organización de los elementos se las reconoce como listas y se pueden clasificar en cuatro categorías :  Listas simplemente enlazadas. Cada nodo (elemento) contiene un único enlace que lo conecta al nodo siguiente o nodo sucesor. La lista es eficiente en recorridos directos (“adelante”), normalmente se lo grafica así:  Listas doblemente enlazadas. Cada nodo contiene dos enlaces, uno a su nodo predecesor y otro a su nodo sucesor. La lista es eficiente tanto en recorrido directo (“adelante”) como en recorrido inverso (“atrás”) se lo grafica así:  Lista circular simplemente enlazada. Una lista enlazada simplemente en la que el último elemento (cola) se enlaza al primer elemento (cabeza) de tal modo que la lista puede ser recorrida de modo circular (“en anillo”). 24 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  25. 25. LISTASSIMPLEMENTEENLAZADAS Se considera una lista simplemente enlazada donde cada nodo tiene un único campo de enlace o referencia a otro elemento de la misma estructura, normalmente se cuenta con una variable estática que contiene la referencia al primer nodo de la estructura, así cada nodo (excepto el último) enlazará con el nodo siguiente, y el enlace del último nodo contendrá NULL para indicar el final de la lista. Por la forma de tratar a los nodos se clasifican en: 1. PILAS Lista LIFO (Last Input, First Output/último en entrar, primero en salir) 2. COLAS Lista FIFO (First Input, First Output/primero en entrar, primero en salir) Es una lista ordinal o estructura de datos secuencial en la que el modo almacenar y recuperar los datos consiste en aplicar la regla LIFO dónde el último nodo en entrar es el primero en salir. Es una lista ordinal o estructura de datos secuencial en la que el modo almacenar y recuperar los datos consiste en aplicar la regla FIFO dónde el primer nodo en entrar es el primer nodo en salir. A una lista se la definen como un conjunto de nodos en secuencia sin reglas específicas del cual siempre se puede conocer el nodo inicial y el nodo final así como cada nodo de la lista, su estructura puede ser usada para implementar otras estructuras de datos. 3. LISTAS ABIERTAS 25 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  26. 26. LISTASSIMPLEMENTEENLAZADASABIERTAS La estructura de almacenamiento de cada nodo de la lista es igual a la utilizada en las otras estructuras: Con la lista enlazada existe un nodo cabecera y todos los elementos de la lista tendrán un elemento previo, puesto que el previo del primer elemento es la cabecera, el último de la lista tendrá como referencia null. public class Nodo { private int valor; // Variable o lista de variables para guardar datos. private Nodo sig; // Atributo para hacer referencia al nodo siguiente. // Métodos get y set para los atributos. public int getValor() { return valor; } public void setValor(int valor) { this.valor = valor; } public Nodo getSig() { return sig; } public void setSig(Nodo sig) { this.sig = sig; } } El atributo valor es un modelo que puede ser reemplazado por otros atributos, el atributo Sig será quien almacene la referencia a la siguiente variable sin nombre, observe que este atributo es del mismo tipo de la clase Nodo En este tipo de estructura de datos, los elementos se encuentran ordenados de manera consecutiva, pueden ser insertados o extraídos desde cualquier ubicación de la estructura. // Método constructor que inicializamos el valor de las variables. public Nodo(){ this.valor = 0; this.sig = null; } Recuerde que los métodos constructores sirven para inicializar los atributos, así valor tomará cero y Sig tomará null que significa último de la estructura Recuerde que los métodos Get y Set sirven para extraer e insertar valores a cada atributo de la clase porque son privados Una lista vacía corresponde a una cabecera cuya referencia tiene null. cabecera 26 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  27. 27. Una vez que se tiene la clase Nodo, se crea la clase Lista que podrá contener una diversidad de métodos de ingresos, recorridos y extracciones: public boolean esVacia(){ return cabecera == null; } public void agregarAlFinal(int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera = nuevo; } else{ Nodo aux = cabecera; // Recorre la lista hasta llegar al ultimo nodo while(aux.getSig() != null){ aux = aux.getSig (); } // Agrega el nuevo nodo al final de la lista. aux.setSig(nuevo); } } public class Lista { private Nodo cabecera; public Lista(){ cabecera = null; } Para recorrer toda la estructura se utiliza la variable aux que avanzará mientras la referencia sea diferente de null public void agregarAlInicio(int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera = nuevo; } else{ // Une el nuevo nodo con la lista existente. nuevo.setSig(cabecera); // Renombra al nuevo nodo como el inicio de la lista. cabecera = nuevo; } } aux tomara la referencia de la primera variable dinámica y llegará hasta la última de la lista (la que tiene null) Proceso de avanzar a la siguiente variable Este algoritmo es similar al utilizado por la Pila porque agrega los nuevos nodos al principio de la lista, se considera el método de amarre más fácil. LISTASSIMPLEMENTEENLAZADASABIERTAS:INSERT AR 27 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  28. 28. cabecera null public void agregarAlInicio (int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera = nuevo; } else{ nuevo.setSig(cabecera); cabecera = nuevo; } } 23, 8, 11, 17, 10 null 23 1 8 2 11 17 10 3 4 1 2 3 4 5 Esta posibilidad de inserción es igual a la utilizada por las listas con reglas Pila: LISTASSIMPLEMENTEENLAZADASABIERTAS:INSERT AR 28 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  29. 29. public void agregarAlFinal(int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera = nuevo; } else{ Nodo aux = cabecera; // Recorre la lista hasta llegar al ultimo nodo while(aux.getSig() != null){ aux = aux.getSig (); } // Agrega el nuevo nodo al final de la lista. aux.setSig(nuevo); } } 23, 8, 11, 17, 10 null 23 2 8 3 11 17 10 4 5 cabecera null 1 aux 1 aux 2 aux 3 aux 4 Esta posibilidad de inserción es igual a la utilizada por las listas con reglas Cola, se diferencia en que no utiliza un puntero fijo para insertar al final: Este algoritmo utiliza aux para recorrer los nodos y ubicarse en el último ingresado, empieza desde cabecera y avanza mientras la referencia sea diferente de null, recuerde que cada vez que se crea una variable dinámica, esta de inicializa con 0 para la variable valor y null para la variable sig. Por lo tanto la última variable siempre tendrá null como referencia. LISTASSIMPLEMENTEENLAZADASABIERTAS:INSERT AR 29 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  30. 30. public boolean buscar(int referencia){ Nodo aux = cabecera; boolean encontrado = false; // Recorrido de la lista hasta encontrar el elemento o el final while(aux != null && encontrado != true){ // Consulta si el valor del nodo es igual al de referencia. if (referencia == aux.getValor()){ encontrado = true; } else{ aux = aux.getSiguiente(); } } return encontrado; } null 23 2 8 3 11 17 10 4 5 cabecera 1 aux 1 aux 2 aux 3 aux 4 Este algoritmo sirve para verificar la existencia o no de un determinado valor en el lista: referencia 17 encontrado false true  El algoritmo utiliza una variable de estado (encontrado) que identifica si ya ha sido encontrada o no el valor de referencia  La evaluación de repetición del control while indica que volverá a repetir mientras no haya llegado al final y no se lo ha encontrado, por esta razón la variable encontrado se inicializa con false ya que, en caso de no encontrarlo mantendrá el valor y devolverá falso  La condición interna verifica si existe el valor, caso contrario avanzará con el siguiente nodo LISTASSIMPLEMENTEENLAZADASABIERTAS:BUSCAR 30 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  31. 31. LISTASSIMPLEMENTEENLAZADASABIERTAS:INSERT AR cabecera 1 23 8 2 11 17 3 4 null public void insertarPorReferencia(int referencia, int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (!esVacia()) { // Consulta si el valor existe en la lista. if (buscar(referencia)) { Nodo aux = cabecera; // Recorre la lista hasta llegar al nodo de referencia. while (aux.getValor() != referencia) { aux = aux.getSig(); } // Crea un respaldo de la continuación de la lista. Nodo siguiente = aux.getSig(); // Enlaza el nuevo nodo después del nodo de referencia. aux.setSig(nuevo); // Une la continuacion de la lista al nuevo nodo. nuevo.setSig(siguiente); } } } 5 10 Esta posibilidad de inserción permite agregar un elemento después de un nodo que sirve de referencia: 3 aux 1 aux 2 siguiente 3 nuevo referencia 8 valor 10 Por ejemplo, se insertará el nodo con el valor 10 después del nodo con valor 8  Este ejemplo utiliza el método buscar() que devuele verdadero si existe un determinado valor en la lista, o falso en caso de no existir  Este algoritmo utiliza dos variables estáticas (aux y siguiente) de referencias para insertar una variable dinámica entre los dos nodos.  Este método es útil para agregar elementos en cualquier posición conociendo que se insertará después de la referencia enviada. 31 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  32. 32. LISTASSIMPLEMENTEENLAZADASABIERTAS public void actualizarPorReferencia(int referencia, int valor){ if (buscar(referencia)) { Nodo aux = cabecera; // Recorre la lista hasta llegar al nodo de referencia. while(aux.getValor() != referencia){ aux = aux.getSig(); } // Actualizamos el valor del nodo aux.setValor(valor); } } null 23 2 8 3 11 17 10 4 5 cabecera 1 aux 1 aux 2 aux 3 Este algoritmo sirve para actualizar o modificar el contenido de una variable: referencia 11 Valor 45 El algoritmo realiza la actualización si el elemento existe en la lista, así que el recorrido se dará mientras el valor del nodo sea diferente del valor buscado. 45 32 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  33. 33. LISTASSIMPLEMENTEENLAZADASABIERTAS public void mostrarLista(){ if (!esVacia()) { Nodo aux = cabecera; int i = 0; // Posición de los elementos en la lista. // Recorre la lista hasta el final. while(aux != null){ System.out.print(i + ".[ " + aux.getValor() + " ]" + " -> "); aux = aux.getSig(); i++; } } } El siguiente algoritmo sirve para mostrar la lista numerada de todos los elementos de esta estructura: null 23 2 8 3 11 17 10 4 5 cabecera 1 aux 1 aux 2 aux 3 aux 4 aux 5 0.[23]-> 1.[8]-> 2.[11]-> 3.[17]-> 4.[10]-> i 2 3 4 5 0 1 null 33 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  34. 34. LISTASSIMPLEMENTEENLAZADASABIERTAS:ACCESO La variable estática cabecera puede acceder a los contenidos de otras variables dinámicas aparte de la primera, es una característica de todos los lenguajes de programación, esto se logra porque tiene la referencia a la primera variable dinámica y a su vez la primera tiene referencia a la segunda y así sucesivamente hasta la última de la estructura Por ejemplo, para acceder al valor y la dirección que contiene la primera variable dinámica se lo haría así: Por ejemplo, suponga que desea acceder al valor y la dirección que contiene la segunda variable dinámica: Por ejemplo, suponga que desea acceder al contenido de la las variables dinámicas de la siguiente estructura: Cabecera 1 cabecera.getValor(); //esto devuelve 11 cabecera.getSig(); //esto devuelve 2 cabecera.getSig().getValor(); //esto devuelve 8 cabecera.getSig().getSig(); //esto devuelve 3 getSig() devolverá la referencia de la segunda variable (2). (2). getValor() devuelve el valor que tiene la variable 2 (8) getSig() devolverá la referencia de la segunda variable (2). (2). getSig() devuelve la referencia que tiene la variable 2 (3) 34 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  35. 35. LISTASSIMPLEMENTEENLAZADASABIERTAS:ELIMINACIÓN // Método elimina lista public void eliminar(){ cabecera = null; } En Java una vez que una variable dinámica no se encuentra referenciada se elimina automáticamente null public void eliminarPorReferencia(int referencia){ if (buscar(referencia)) { // Consulta si el nodo a eliminar es el primero if (cabecera.getValor() == referencia) { // El primer nodo apunta al siguiente. cabecera = cabecera.getSig(); } else{ Nodo aux = cabecera; while(aux.getSig().getValor() != referencia){ aux = aux.getSig(); } // Guarda el nodo siguiente del nodo a eliminar. Nodo siguiente = aux.getSig().getSig(); aux.setSig(siguiente); } } } null 23 2 8 3 11 17 10 4 5 cabecera 1 aux 1 aux 2 siguiente 4 Este algoritmo sirve para verificar la existencia o no de un determinado valor en el lista: referencia 11  El algoritmo muestra la posibilidad de acceder a datos de variables dinámicas siguientes a la que se esta referenciando  La evaluación del recorrido en el control while indica que volverá a repetir mientras el valor de la siguiente variable es diferente a la buscada 5 35 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  36. 36. LISTASSIMPLEMENTEENLAZADASABIERTA:ESTRUCTURA COMPLET A public class Lista { private Nodo cabecera; public Lista(){ cabecera = null;} public boolean esVacia(){ return cabecera == null;} public void agregarAlInicio(int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera = nuevo; } else{ nuevo.setSig(cabecera); cabecera = nuevo; }} public void agregarAlFinal(int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera = nuevo; } else{ Nodo aux = cabecera; while(aux.getSig() != null){ aux = aux.getSig (); } aux.setSig(nuevo); }} public boolean buscar(int referencia){ Nodo aux = cabecera; boolean encontrado = false; while(aux != null && encontrado != true){ if (referencia == aux.getValor()){ encontrado = true; } else{ aux = aux.getSiguiente(); } } return encontrado;} public void actualizarPorReferencia(int referencia, int valor){ if (buscar(referencia)) { Nodo aux = cabecera; while(aux.getValor() != referencia){ aux = aux.getSig(); } aux.setValor(valor); }} public void mostrarLista(){ if (!esVacia()) { Nodo aux = cabecera; int i = 0; while(aux != null){ System.out.print(i + ".[ " + aux.getValor() + " ]" + " -> "); aux = aux.getSig(); i++; } }} public void eliminarPorReferencia(int referencia){ if (buscar(referencia)) { if (cabecera.getValor() == referencia) { cabecera = cabecera.getSig(); } else{ Nodo aux = cabecera; while(aux.getSig().getValor() != referencia){ aux = aux.getSig(); } Nodo siguiente = aux.getSig().getSig(); aux.setSig(siguiente); } }} public void insertarPorReferencia(int referencia, int valor){ Nodo nuevo = new Nodo(); nuevo.setValor(valor); if (!esVacia()) { if (buscar(referencia)) { Nodo aux = cabecera; while (aux.getValor() != referencia) { aux = aux.getSig(); } Nodo siguiente = aux.getSig(); aux.setSig(nuevo); nuevo.setSig(siguiente); } }} 36 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  37. 37. LISTASSIMPLEMENTEENLAZADASCIRCULAR Se trata de una lista de Nodos organizados de modo que, cada uno almacena la referencia del siguiente y el último contiene la referencia del primero, esto daría a entender que los nodos están enlazados de forma circular, en esta estructura ningún nodo tendrá null por lo que no existe el último como la Pila y las Colas a excepción de la Cola Circular. En las listas circulares para agregar o quitar un Nodo se lo puede hacer desde cualquier ubicación, solo necesitaría mover a la variable estática que tiene la referencia a la lista, un recorrido requiere de la ayuda de otra variable de referencia ya que se podría generar un recorrido infinito. Como cada una apunta a la otra, la referencia de acceso puede ser a cualquiera de la lista como si se tratara del primero public class Nodo { private int valor; // Variable o lista de variables para guardar datos. private Nodo sig; // Atributo para hacer referencia al nodo siguiente. // Métodos get y set para los atributos. public int getValor() { return valor; } public void setValor(int valor) { this.valor = valor; } public Nodo getSig() { return sig; } public void setSig(Nodo sig) { this.sig = sig; } } // Método constructor que inicializamos el valor de las variables. public Nodo(){ this.valor = 0; this.sig = null; } Para crear la estructura de la variable dinámica en la lista circular se utiliza la misma clase Nodo utilizada en las otra estructuras: 37 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  38. 38. LISTASSIMPLEMENTEENLAZADASCIRCULAR Para es desarrollo de esta estructura se utilizará el nombre cabecera para definir la variable estática que tiene la referencia de acceso a la estructura, por ser una estructura circular, se pueden ingresar elementos al principio o al final de forma similar a las colas circulares de la clase anterior //Método IsEmpty public boolean esVacia(){ return cabecera == null;} public void InsertarInicio(int valor) { Nodo nuevo=new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera=nuevo; //cabecera tomará la referencia del primer nodo nuevo.setSig(cabecera); //como es el primero se referencia a si mismo. } else { Nodo aux=cabecera; do{ aux=aux.getSig(); //aux avanzará hasta ubicarse antes de cabecera }while ( aux.getSig()!=Cabecera); aux.setSig(nuevo); //Antes de cabecera se insertará en nuevo nodo nuevo.setSig(Cabecera); //El nuevo nodo apunta al primero Cabecera=nuevo; //Ahora el primero será el nuevo nodo } } public class ListaCircular { private Nodo cabecera; //Método constructor public ListaCircular(){ cabecera = null; } En estos algoritmos se requiere de dos variables de referencias para agregar nuevos elementos al principio o al final, la variable aux servirá de ayuda para ambas inserciones public void InsertarFinal(int valor) { Nodo nuevo=new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera=nuevo; nuevo.setSig(cabecera); } else { Nodo aux=cabecera; do{ aux=aux.getSig(); //avanzará hasta ubicarse antes de cabecera }while ( aux.getSig()!=cabecera); aux.setSig(nuevo); //Antes de cabecera se insertará en nuevo nodo nuevo.setSig(cabecera); //El nuevo nodo apunta al primero } } 38 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  39. 39. LISTASSIMPLEMENTEENLAZADASCIRCULAR:INSERT AR aux public void InsertarInicio(int valor) { Nodo nuevo=new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera=nuevo; nuevo.setSig(cabecera); } else { Nodo aux=cabecera; do{ aux=aux.getSig(); }while ( aux.getSig()!=Cabecera); aux.setSig(nuevo); nuevo.setSig(Cabecera); Cabecera=nuevo; } } ALGORITMO DE INSERCIÓN: 23 8 11 17 10 4 5 1 2 3 4 cabecera null 1 3 2 1 2 3 4 5 Suponga que se desea insertar los siguientes elementos: 23, 8, 11, 17, 10 a una lista circular vacía 39 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  40. 40. LISTASSIMPLEMENTEENLAZADASCIRCULAR:INSERT AR aux public void InsertarFinal(int valor) { Nodo nuevo=new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera=nuevo; nuevo.setSig(cabecera); } else { Nodo aux=cabecera; do{ aux=aux.getSig(); }while ( aux.getSig()!=cabecera); aux.setSig(nuevo); nuevo.setSig(cabecera); } } ALGORITMO DE INSERCIÓN: Suponga que se desea insertar los siguientes elementos: 23, 8, 11, 17, 10 a una lista circular vacía 1 23 2 8 3 11 17 10 4 5 1 2 3 4 cabecera null 1 40 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  41. 41. LISTASSIMPLEMENTEENLAZADASCIRCULAR:RECORRER public boolean esVacia(){ return cabecera == null; } public void InsertarInicio(int valor) { Nodo nuevo=new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera=nuevo; nuevo.setSig(cabecera); } else { Nodo aux=cabecera; do{ aux=aux.getSig(); }while ( aux.getSig()!=Cabecera); aux.setSig(nuevo); nuevo.setSig(Cabecera); Cabecera=nuevo; } } public class ListaCircular { private Nodo cabecera; //Método constructor public ListaCircular(){ cabecera = null; } Ambos métodos son iguales en el recorrido pero se diferencian en la condición de parada. El recorrido del método MostrarCompleto parte de cabecera y llega hasta el nodo anterior de cabecera. El recorrido del método MostrarIncompleto parte de cabecera y llega hasta el nodo antes de cabecera. public void InsertarFinal(int valor) { Nodo nuevo=new Nodo(); nuevo.setValor(valor); if (esVacia()) { cabecera=nuevo; nuevo.setSig(cabecera); } else { Nodo aux=cabecera; do{ aux=aux.getSig(); }while ( aux.getSig()!=cabecera); aux.setSig(nuevo); nuevo.setSig(cabecera); } } public void MostrarCompleto() {if (Cabecera==null) return; //si esta vacía terminará Nodo aux=cabecera; //aux iniciará en cabecera do{System.out.println(aux.getValor()); aux=aux.getSig(); //Avanza al siguiente nodo de la lista }while (aux!=cabecera); //aux llegará antes de cabecera } public void MostrarIncompleto() {if (Cabecera==null) return; //si esta vacía terminará Nodo aux=cabecera; //aux iniciará en cabecera do{System.out.println(aux.getValor()); aux=aux.getSig(); //Avanza al siguiente nodo de la lista }while ( aux.getSig()!=cabecera); //aux llegará a un nodo antes de cabecera } 41 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  42. 42. LISTASSIMPLEMENTEENLAZADASCIRCULAR:RECORRER public void MostrarCompleta() {if (cabecera==null) return; Nodo aux=cabecera; do{ System.out.println(aux.getValor()); aux=aux.getSig(); }while (aux!=cabecera); } public void MostrarIncompleta() {if (cabecera==null) return; Nodo aux=cabecera; do{ System.out.println(aux.getValor()); aux=aux.getSig(); }while (aux.getSig()!=cabecera); } 11 8 23 16 9 Cabecera 1 aux 1 aux 2 aux 3 aux 4 aux 5 1 1 Resultado del recorrido completo: Resultado del recorrido incompleto: 11 8 23 16 La utilidad de este método esta en la ubicación del ultimo nodo (técnicamente anterior a cabecera) ya que no serviría para mostrar los datos 42 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  43. 43. LISTASSIMPLEMENTEENLAZADASCIRCULAR:BUSCAR  Si la lista está vacía, significa que no se tendrá que realizar la búsqueda. public boolean Buscar(int Abuscar) { if(esVacia()){ //System.out.println("Lista vacía.."); return false; } Nodo aux=cabecera; do{ if(aux.getValor()==Abuscar){ //System.out.println("Valor encontrado"); return true;} else{ aux=aux.getSig();} }while(aux!=cabecera); //System.out.println("Valor no existe en la lista"); return false; } El siguiente algoritmo muestra verdadero si el elemento existe o falso en caso de no encontrarlo  Puede ser posible que la búsqueda no se tenga resultado exitoso, porque el nodo buscado no existe, o en el mejor de los casos se tenga éxito al encontrarlo.  En caso contrario se deberá recorrer cada nodo, comparando el valor a buscar, con el valor de cada nodo hasta llegar a un nodo antes de la cabecera (técnicamente el último). aux 1 aux 2 aux 3 aux 4 aux 5 Cabecera 1 Abuscar 30 23 Devuelve: Verdadero Devuelve: Falso 43 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  44. 44. LISTASSIMPLEMENTEENLAZADASCIRCULAR:ACTUALIZAR public void Modificar(int Abuscar, int cambio) { if(esVacia()){ //System.out.println("Lista vacía.."); return;} Nodo aux=cabecera; do{ if(aux.getValor()==Abuscar) { aux.setValor(valor); //System.out.println("Valor modificado"); return; } else { aux=aux.getSig(); } //Avanza al siguiente nodo }while(aux!=cabecera); //Rebota si no ha llegado al final System.out.println("Valor no existe en la lista");}  Si la lista está vacía, significa que no se tendrá que realizar la búsqueda.  Puede ser posible que la búsqueda no se tenga resultado exitoso, porque el nodo buscado no existe, o en el mejor de los casos se tenga éxito y se pueda actualizar el valor.  En caso contrario se deberá recorrer cada nodo, comparando el valor a buscar, con el valor de cada nodo hasta llegar a un nodo antes de la cabecera (técnicamente el último). El siguiente algoritmo actualiza el valor de un elemento: aux 1 aux 2 aux 3 Cabecera 1 Abuscar 23 cambio 33 33 44 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  45. 45. LISTASSIMPLEMENTEENLAZADASCIRCULAR:ELIMINAR  Si la lista está vacía, significa que no se tendrá que realizar la eliminación. public void EliminaCabecera() { if (esVacia()) { return; } Nodo aux=cabecera; do{aux=aux.getSig(); }while(aux.getSig()!=cabecera);//Rebota si no ha llegado al último nodo aux.setSig(cabecera.getSig()); //El último nodo se conecta al segundo cabecera=cabecera.getSig(); //cabecera ahora apuntará al segundo if (aux==cabecera) {//Si solo hay un nodo, se lo elimina de forma automática Cabecera=null;} } Para eliminar toda la lista circular: En Java será sencillo y bastará con ubicar a la cabecera el valor de null. public void EliminarTodo() { cabecera=null; System.out.print(“Lista eliminada”); }  En caso contrario se deberá recorrer toda la estructura hasta llegar al nodo anterior de la cabecera (técnicamente el último).  El ultimo nodo se conectará con el segundo de la estructura eliminando al primero de la lista. El siguiente algoritmo elimina el primer elemento de una lista circular simplemente enlazada: aux 1 aux 2 aux 3 aux 4 aux 5 cabecera 1 2 2 cabecera null Lista eliminada 45 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  46. 46. LISTASSIMPLEMENTEENLAZADASCIRCULAR:ELIMINAR Elimina sólo el último Nodo de la Listas circular simplemente enlazada public void EliminaUltimo() { if (esVacia()) { return; } Nodo ant, aux=cabecera; do{ ant=aux; //ant se ubica en la posición anterior a aux aux=aux.getSig();} } while(aux.getSig()!=cabecera);//Rebotará hasta llegar al último ant.setSig(aux.getSig()); //El penúltimo apunta al primero de la lista if (aux==cabecera) { cabecera=null; } //si es el único será borrado automáticamente }  Si la lista está vacía, significa que no se tendrá que realizar la eliminación.  En caso que lista tenga nodos, el algoritmo deberá usar una variable auxiliar que se moverá desde la cabecera hasta el último nodo que esta antes de la cabecera, cada vez que la variable auxiliar se mueve a la siguiente, otra variable debe apuntar al nodo anterior, como se eliminará el último el anterior a éste deberá apuntar al primero.  En caso de tener 1 nodo, se ubica null a la cabecera y automáticamente la lista quedará vacía. El siguiente algoritmo elimina el último elemento de una lista circular simplemente enlazada: aux 1 aux 2 aux 3 aux 4 aux 5 Cabecera 1 ant 1 ant 1 ant 1 ant 1 1 46 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  47. 47. LISTASSIMPLEMENTEENLAZADASCIRCULAR:TRUCOS La variable estática cabecera puede acceder a los contenidos de otras variables dinámicas aparte de la primera, es una característica de todos los lenguajes de programación, esto se logra porque tiene la referencia a la primera variable dinámica y a su vez la primera tiene referencia a la segunda y así sucesivamente hasta la última de la estructura Por ejemplo, para acceder al valor y la dirección que contiene la primera variable dinámica se lo haría así: Por ejemplo, suponga que desea acceder al valor y la dirección que contiene la segunda variable dinámica: Por ejemplo, suponga que desea acceder al contenido de la las variables dinámicas de la siguiente estructura: Cabecera 1 cabecera.getValor(); //esto devuelve 11 cabecera.getSig(); //esto devuelve 2 cabecera.getSig().getValor(); //esto devuelve 8 cabecera.getSig().getSig(); //esto devuelve 3 getSig() devolverá la referencia de la segunda variable (2). (2). getValor() devuelve el valor que tiene la variable 2 (8) getSig() devolverá la referencia de la segunda variable (2). (2). getSig() devuelve la referencia que tiene la variable 2 (3) cabecera.getSig(cabecera.getSig()); getSig() devolverá la referencia de la segunda variable (2). getSig(2) devuelve la referencia que tiene la variable 2 (3) public Nodo getSig(Nodo x) { return x.sig; } Otra posibilidad sería mediante la creación de un método que reciba una referencia, por ejemplo : 47 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  48. 48. LISTASSIMPLEMENTEENLAZADASCIRCULAR:ELIMINARXELEMENTO • Este proceso requiere hacer una búsqueda y Si la lista está vacía, significa que no se tendrá que realizar la búsqueda. • En caso que exista la lista se deberá recorrer cada nodo e ir comparando con el valor del nodo a buscar para eliminar. public void Elimina(int Abuscar) { boolean encontrado=false; if (esVacia()) { return; } Nodo ant, aux=cabecera; do{ if(aux.getValor()== Abuscar ) { encontrado=true; } // Si lo encuentra se activa la variable else { ant=aux; aux=aux.getSig(); } } while(aux!=Cabecera && !encontrado); if (encontrado) { //si es encontrado if (aux==cabecera && aux.getSig()==cabecera) { cabecera=null; } //verifica si es el único nodo else{ //verifica si es el primero de la lista if (aux==cabecera){ ant.setSig(cabecera.getSig()); cabecera= cabecera.getSig(); } else { ant.setSig(aux.getSig()); } } }} 4 aux 1 aux 2 aux 3 ant 1 ant 1 Cabecera 1 Abuscar 23 encontrado true false 48 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  49. 49. LISTASSIMPLEMENTEENLAZADASCIRCULAR:ELIMINARXELEMENTO El siguiente algoritmo es otra alternativa de eliminación, analice sus instrucciones y realice la prueba de funcionamiento para verificar su funcionamiento. public void Elimina(int Abuscar) {if (esVacia()) {//System.out.println(“LCS Vacía..”); return; } Nodo aux, ant=cabecera; //ant.getSig() devuelve una referencia que llama getValor() para compararlo do{ if (ant.getSig().getValor()==Abuscar){ aux=ant.getSig(); ant.setSig(aux.getSig()); //En caso de ser el primero que se eliminará if (aux==cabecera) { cabecera=aux.getSig(); } //En caso de ser el único nodo a eliminar if (aux==cabecera) { cabecera=null; } return; } else{ ant=ant.getSig(); } } while(ant!=cabecera); //Rebota mientras no llegue al primero System.out.print(“No existe el dato a eliminar..”); } cabecera 1 Abuscar 23 aux ant 49 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES
  50. 50. ACTIVIDADES Diseñe el proceso de prestamos de libros de una biblioteca. Implementar con:  Vectores.  Listas simplemente enlazadas abiertas.  Listas simplemente enlazadas cerradas. . 50 ALGORITMOSY ESTRUCTURAS DEDATOS CHRISTIANTORRES

×