data structure

1. UNIVERSIDADTÉCNICADEMANABÍ
DEPARTAMENTODETECNOLOGÍAS
DELAINFORMACIÓNYLA
COMUNICACIÓN
ALGORITMOS Y
ESTRUCTURAS DE
DATOS
Por Christian Torres.
UNIDAD II

2. WOODGROVE
BANK
U2-TEMA 3
ARREGLOS
2
ALGORITMOSY
ESTRUCTURAS
DEDATOS
CHRISTIANTORRES

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. 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. 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. 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. 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. ARRAYSUNIDIMENSIONALES
Nota: También puede acceder a los arrays de Java utilizando el bucle for-each
8
ALGORITMOSY
ESTRUCTURAS
DEDATOS
CHRISTIANTORRES

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. WOODGROVE
BANK
U2-TEMA4
LISTAS SIMPLEMENTE ENLAZADAS
2
22
ALGORITMOSY
ESTRUCTURAS
DEDATOS
CHRISTIANTORRES

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