LISTAS ENLAZADAS
 
LISTAS ENLAZADAS
Mis aficiones
Album de fotos
Curriculum vitae
Mis enlaces favoritos
LISTAS ENLAZADAS
 
imagen
Imagen
 
laboratorio en clase de estructutas
PROGRAMA No. 2 Enuncie las características de Listas encadenadas con arreglos y documente en donde sea necesario destacar estas características.
// Listas.java
// Programa de Listas encadenadas representadas con arreglos
// Compilar: javac Listas.java
// Ejecutar: java Listas
// =====================================================
import java.io.*;

public class Listas {
publicstaticclassClaseListas { // Declaracion de la clase de Listas
static char dato[]=new char[100];
staticintsn[]=new int[100];
staticintapui, top;

ClaseListas() { // Constructor de la ClaseListas
apui=-1;
top=0;
System.out.println("Lista enlazada inicializada !!!");
System.out.println("apui="+apui);
System.out.println("top ="+top);

// Se crea una lista en forma de arreglo con un tope 100 espacios y con una inicialización en -1.

}
public static void Mostrar() {
int i=0;
System.out.println("

<<< MOSTRAR ESTRUCTURA >>>");
if(apui==-1) System.out.println("
Lista enlazada vacia !!!
");
System.out.println("posiciondatosn");
System.out.println("---------------------------");
for(i=0;i<top;i++) {
System.out.println(i+" | "+dato[i]+" | "+sn[i]);
}
System.out.println("apui="+apui);
System.out.println("top="+top);
}


// Imprime lo mostrado en el contenido de la lista

public static void Insertar(char elemento) {
int i=0, ant=0;
if(apui==-1) { //Alta en Lista vacia
System.out.println("Insertar dato en lista vacia ...");
apui=top;
dato[top]=elemento;
sn[top]=-1;
top++;
return;
}
i=apui;
do {
if(dato[i]==elemento) {
System.out.println("Duplicado !!!");
return;
}
if(elemento<dato[i]) {
if(i==apui) { //Alta al principio
System.out.println("Insertando el dato menor de todos ...");
dato[top]=elemento;
sn[top]=apui;
apui=top;
top++;
return;
} else {
System.out.println("Alta intermedia ...");
dato[top]=elemento;
sn[top]=sn[ant];
sn[ant]=top;
top++;
return;
}
}
ant=i;
i=sn[i];
}while(i!=-1);
System.out.println("Alta al final ...");
dato[top]=elemento;
sn[top]=-1;
sn[ant]=top;
top++;
return;
}
}

// Inserta un elemento tipo carácter al final de la lista y a la vez este verifica si el dato está repetido.
.
staticClaseListas Lista=new ClaseListas();

public static void main(String args[]) throws IOException {
int op=0;
do {
System.out.println("

<<< LISTAS ENLAZADAS >>>");
System.out.println("1.- Altas");
System.out.println("2.- Mostrarestructura");
System.out.print("Opcion? ---> ");
op=getInt();
switch(op) {
case 1 : Altas(); break;
case 2 : Lista.Mostrar(); break;
}
}while(op!=0);
}

// Crea una nueva lista, la enlaza con la anterior y permite la opción de mostrar la estructura.

public static void Altas() throws IOException {
char dato;
System.out.println("

<<< ALTAS >>>");
System.out.print("Dato a insertar ---> ");
dato=getChar();
Lista.Insertar(dato); //Invocar el metodo Insertar del objeto Lista
}

// Método para insertar que no devuelve datos.

public static String getString() throws IOException {
InputStreamReaderisr = new InputStreamReader(System.in);
BufferedReaderbr = new BufferedReader(isr);
String s = br.readLine();
return s;
}

// Recorre el arreglo retornando un dato tipo carácter.

public static intgetInt() throws IOException {
String s = getString();
returnInteger.parseInt(s);
}

// Retorna el elemento que entra como tipo carácter y loretorna tipo entero.

}

LISTAS ARREGLOS
• El orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco • Los elementos enlazados tienen un orden predeterminado en la memoria del disco
• El orden de recorrido de la lista es diferente al de almacenamiento. • El orden de recorrido es igual al del almacenamiento
• Permite insertar elementos indefinidamente lo que implica optimización de memoria • Necesita ser redimensionado pues tarde o temprano se llena y ocupa mas memoria
• Acceso secuencial u ordenado a los elementos • Acceso aleatorio a los elementos
• •
• En listas enlazadas acceso secuencial lento • El acceso secuencial es más rápido
• Almacenamiento extra necesario para las referencias como caracteres o valores booleanos • Almacenamiento justo para las referencias se ahorra espacio.
• Al ser secuencial la búsqueda de los elementos resulta lenta • Al ser aleatorio la búsqueda de los elementos es más rápida
• Lento al asignar memoria para cada nuevo elemento • Memoria es asignada en la creación del arreglo


PROGRAMA No. 3. Realice un cuadro comparativo de Lista encadenadas, representadas con Arreglos, Objetos y recursivamente.



ARREGLOS OBJETOS RECURSIVAMENTE
Unidimensionalmente o Bidimensionalmente Operaciones Definidas Llamado a Métodos
Memoria Estática Memoria Dinámica Memoria Dinámica
Tamaño Definido Ninguno Tamaño Indefinido



PROGRAMA No. 4. Digite y Analice el siguiente Código y documente los tipos de recursión que se utilizan. Enunciar conclusiones.

EL PAKETE SE LLAMA listaenlazadaPrueba
1) implementar una lista enlazada de datos enteros con las funciones básicas y adicionar las siguientes funciones:
packagelistaenlazadaPrueba;

public class Principal
{
public static void main(String[] args)
{
Lista l1= new Lista();

l1.Ingresar(2);
l1.Ingresar(10);
l1.Ingresar(10);
l1.Ingresar(14);
l1.Ingresar(16);
l1.Ingresar(9);
l1.Ingresar(12);
l1.Visualizar();
l1.Buscar(2);
l1.Buscar(8);
l1.EliminarTodo_Recursivo(10);
l1.Visualizar();
l1.MayoryPosicion();
l1.MenoryRepeticion();
l1.Suma_Recursivo();
l1.SumaPares_Recursivo();
l1.MenoresNumero(15);

}
}

//creas una nueva class.

packagelistaenlazadaPrueba;

public class Nodo
{
privateint info;
private Nodo sig;
public Nodo(int n)
{//Creamos variables de entrada=info y siguiente=sig
info=n;
sig=null;

}
// sacar el dato info
publicintSacarInfo()
{//Con este metodo ya tenemos la variable info
returninfo;
}
// Método directo de recursividad.

publicNodoSacarSig()
{
return sig;
}
public void Enlace(Nodo g)
{
sig=g;
}
}

packagelistaenlazadaPrueba;
importjavax.swing.JOptionPane;
importjavax.swing.JTextArea;
public class Lista
{
//Creamos los tipos de nodo
private Nodo primero, ultimo;

//Creacion del constructor
public Lista()
{
primero=ultimo=null;
}
publicbooleanEstaVacia()
{
return primero==null;
}

// Método Directo.

publicvoid Ingresar(int n)
{ //llamamos a la referencia
Nodo p= new Nodo(n);
//entra if
if(EstaVacia())
primero=ultimo=p;
else
{
ultimo.Enlace(p);
ultimo=p;
}

}

// Método Indirecto.

publicvoid Visualizar()
{
Nodo p=primero; String Salida="Datos :
";

while (p!=null)
{
Salida=Salida+ p.SacarInfo()+"
";
p=p.SacarSig();
}

JTextAreaareaSalida= new JTextArea();
areaSalida.setText(Salida);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);

}

public void Buscar(int n)
{
if(EstaVacia())
return;
Nodo p=primero;
String salida="Resultado:
";
while (p!=null &&p.SacarInfo()!=n)
{
p=p.SacarSig();
}
if(p==null)
{
salida=salida+"Dato no encontrado";
}
else
{
salida=salida+"Dato encontrado";
}
JTextAreaareaSalida= new JTextArea();
areaSalida.setText(salida);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);

}

publicvoidBuscar_Recursivo(Nodo p,int n)
{
if(EstaVacia())
return ;

if(p.SacarInfo()!=n)
Buscar(n);
Buscar_Recursivo(p.SacarSig(), n);
}
publicvoidBuscar_Recursivo(int n)
{
Buscar_Recursivo(primero,n);
}

// Método Indirecto.


publicvoid Eliminar(int n)
{

if(EstaVacia())
return ;
Nodo p=primero; Nodo q=null;
while(p!=null &&p.SacarInfo()!=n)
{
q=p;
p=p.SacarSig();
}
if(p==primero)
{
primero=p.SacarSig();
}
else
{
q.Enlace(p.SacarSig());
if(p==ultimo)
ultimo=q;
}
}

// Método Indirecto.

publicvoidEliminarTodo(int n)
{
if(EstaVacia())
return;
Nodo p=primero;
while(p!=null)
{
if(p.SacarInfo()==n)
this.Eliminar(n);
p=p.SacarSig();
}
}

// Método Indirecto.

publicvoidEliminarTodo_Recursivo(Nodo p,int n)
{
if(p==null)
return ;

if(p.SacarInfo()==n)
Eliminar(n);
EliminarTodo_Recursivo(p.SacarSig(), n);
}

// Método Multirecursivo.

publicvoidEliminarTodo_Recursivo(int n)
{
EliminarTodo_Recursivo(primero,n);
}
publicvoidSuma_Recursivo(Nodo p,int s)
{
if(p==null)
{
JTextAreaareaSalida= new JTextArea();
areaSalida.setText("La Suma total es:"+s);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);
return ;
}
Suma_Recursivo(p.SacarSig(), s+p.SacarInfo());
}
publicvoidSuma_Recursivo( )
{
Suma_Recursivo(primero,0);
}
publicint Suma(Nodo p)
{
if(p==null)
return 0;
returnp.SacarInfo()+Suma(p.SacarSig());
}

// Método Directo.
publicvoidSumaDatos()
{
int s=Suma(primero);
}
privateintMaximoNumero(Nodo oNodoTemporal, int numerador)
{
if(oNodoTemporal==null)
{
returnultimo.SacarInfo();

}
if(MaximoNumero(oNodoTemporal.SacarSig(), numerador-1)<=oNodoTemporal.SacarInfo())
{
returnoNodoTemporal.SacarInfo();
}

returnMaximoNumero(oNodoTemporal.SacarSig(),numerador-1);
}

// Método Directo.

public void BuscarPosicion(int n)
{
if(EstaVacia())
return;
Nodo p=primero;
String salida="Resultado:
";
int i=0;
while (p!=null)
{

if(p==null)
{
salida=salida+"Dato no encontrado";
}
if(p.SacarInfo()==n)
{
salida=salida+"Laposicion del dato es :"+i;
}
p=p.SacarSig();
i++;

}
JTextAreaareaSalida= new JTextArea();
areaSalida.setText(salida);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);

}
// Método Multirecursivo.

publicintcontadorDeElementos(){
Nodo oNodoTemporal = primero;
int i=0;
while(oNodoTemporal!=null)
{
i++;
oNodoTemporal=oNodoTemporal.SacarSig();
}
return i;
}

// Método Directo.

publicvoidMayoryPosicion()
{
intmaximo=MaximoNumero(primero, contadorDeElementos());
JTextAreaareaSalida= new JTextArea();
areaSalida.setText("El numeromaximo es :"+maximo+"");
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);
BuscarPosicion(maximo);
}

// Método Directo.

privateintMinimoNumero(Nodo oNodoTemporal, int numerador)
{
if(oNodoTemporal==null)
{
returnultimo.SacarInfo();

}
if(MinimoNumero(oNodoTemporal.SacarSig(), numerador-1)>=oNodoTemporal.SacarInfo())
{
returnoNodoTemporal.SacarInfo();
}

returnMinimoNumero(oNodoTemporal.SacarSig(),numerador-1);
}

public void contadorDeRepeticiones(int n)
{

int i=0;

if(EstaVacia())
{
return;
}
Nodo p=primero;
String salida="Resultado:
";
while (p!=null )
{
if(p.SacarInfo()==n)
{
i++;
}
p=p.SacarSig();
}
if(i==0)
{
salida=salida+"Dato no encontrado";
}
else
{
salida=salida+"Se repite:"+i+" veces";
}
JTextAreaareaSalida= new JTextArea();
areaSalida.setText(salida);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);
}
// Método Indirecto.

publicvoidMenoryRepeticion()
{
intminimo=MinimoNumero(primero, contadorDeElementos());
JTextAreaareaSalida= new JTextArea();
areaSalida.setText("El numerominimo es :"+minimo+"");
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);
contadorDeRepeticiones(minimo);
}
publicvoidSumaPares_Recursivo(Nodo p,int s)
{
if(p==null)
{
JTextAreaareaSalida= new JTextArea();
areaSalida.setText("La Suma de todos loa pares es:"+s);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);
return ;
}
if(p.SacarInfo()%2==0)
{
SumaPares_Recursivo(p.SacarSig(),p.SacarInfo()+s);
}
else{
SumaPares_Recursivo(p.SacarSig(), s);
}
}
//Metodo Directo
publicvoidSumaPares_Recursivo( )
{
SumaPares_Recursivo(primero,0);
}
privatevoidMenoresNumero(Nodo oNodoTemporal, intnumero,String acumulador)
{
if(oNodoTemporal==null)
{
JTextAreaareaSalida= new JTextArea();
areaSalida.setText("Los numeros menores de:"+numero+" son :"+acumulador);
JOptionPane.showMessageDialog(null,areaSalida,"Salida",JOptionPane.INFORMATION_MESSAGE);
return ;

}
if(oNodoTemporal.SacarInfo()<numero)
{
MenoresNumero(oNodoTemporal.SacarSig(), numero, acumulador+" , "+oNodoTemporal.SacarInfo());
}
else
{
MenoresNumero(oNodoTemporal.SacarSig(),numero,acumulador);
}
}
publicvoidMenoresNumero(int n )
{
MenoresNumero(primero,n,"");
}
}
//Metodo Indirecto


 
Este es otro párrafo que puedes editar del mismo modo.
Escríbeme
Me interesa tu opinión