Ejercicio Utilizando Listas Simples 3

1.    Escribir un programa que realice las siguientes tareas:

• Crear una lista enlazada de números enteros positivos al azar, donde la inserción se realiza por el último nodo.

• Recorrer la lista para mostrar los elementos por pantalla.

• Eliminar todos los nodos que superen un valor dado.

 Para este ejercicio es importante el conocimiento de la eliminación de nodos ya que el usuario ingresa un valor a ser evaluado con cada elemento de la lista y estos serán eliminados si superan al valor ingresado. Para lo cual usaremos métodos de eliminación que validaran cada posible caso en el que se encuentre la condición de eliminación:

Main:

import java.util.Scanner;

public class Main 
{

 public static int leerEntero(String texto)
 {
  Scanner leer=new Scanner(System.in);
  System.out.println(texto);
  int dato=leer.nextInt();
  return dato;
 }
 
 public static int menu()
 {
  System.out.println("---Menu---");
  System.out.println("1.- Imprimir lista");
  System.out.println("2.- Eliminar nodos que superen un valor dado");
  System.out.println("3.- Salir");
  
 
  int seleccion=leerEntero("Seleccione una opción: ");
  return seleccion;
 }
 
 public static void main(String[] args) 
 {
  Lista coleccion=new Lista();
  int opcion;
  
  
  coleccion.agregarFin(10);
  coleccion.agregarFin(55);
  coleccion.agregarFin(22);
  coleccion.agregarFin(5);
  coleccion.agregarFin(7);
  coleccion.agregarFin(12);
  
  do
  {
   opcion=menu();
   switch(opcion)
   {
   case 1:
    
    System.out.println("Lista Ingresada:");
    coleccion.imprimir();
    break;
   
   case 2:
    int exp=leerEntero("Ingrese el numero base para eliminar datos");
    coleccion.eliminarLista(exp);
    break;
    
   
   default:
    System.out.println("FIN DEL PROGRAMA");
    break; 
   }
  }while(opcion!=3);

 }

}

Lista:

public class Lista 
{
 public Nodo inicio;
 public Nodo fin;

 public Lista()
 {
  inicio=fin=null;
 }

 public Nodo devolver(int numero)
 {
  Nodo aux=inicio;
  int cont=1;
  while(contexp)
    {
     inicio=fin=null;
    }
    else
    {
     if(inicio.getDato()>exp)
     {
      inicio=inicio.getSiguiente();
     }
     else
     {
      Nodo anterior=inicio;
      Nodo siguiente=inicio.getSiguiente();
      while(anterior!=null)
      {
       if(anterior.getDato()>exp)
       {
        eliminarNodo(anterior.getDato());
       }
       
       anterior=anterior.getSiguiente();
      }
      
      
     }
    }
   }
 
  }   
 }
 
 public void eliminarNodo(int info)
 {
  if(inicio!=null)
  {
   if(inicio==fin&&inicio.getDato()==info)
   {
    inicio=fin=null;
   }
   else
   {
    if(inicio.getDato()==info)
    {
     inicio=inicio.getSiguiente();
    }
    else
    {
     Nodo anterior=inicio;
     Nodo siguiente=inicio.getSiguiente();
     
     while(siguiente!=null&&siguiente.getDato()!=info)
     {
      anterior=siguiente;
      siguiente=siguiente.getSiguiente();
     }
     
     if(siguiente!=null)
     {
      anterior.setSiguiente(siguiente.getSiguiente());
      if(siguiente==fin)
      {
       fin=anterior;
      }
     }
    }
   }
  }
 }

}

Nodo:

public class Nodo 
{
 private int dato;
 private Nodo anterior;
 private Nodo siguiente;

 public Nodo(int dato, Nodo anterior, Nodo siguiente)
 {
  this.dato=dato;
  this.anterior=anterior;
  this.siguiente=siguiente;
 }

 public Nodo(int dato)
 {
  this.dato=dato;
  this.anterior=null;
  this.siguiente=null;
 }

 public int getDato() 
 {
  return dato;
 }

 public void setDato(int dato) 
 {
  this.dato = dato;
 }

 public Nodo getAnterior() 
 {
  return anterior;
 }

 public void setAnterior(Nodo anterior) 
 {
  this.anterior = anterior;
 }

 public Nodo getSiguiente() 
 {
  return siguiente;
 }

 public void setSiguiente(Nodo siguiente)
 {
  this.siguiente = siguiente;
 }

}

Ejecucion en consola:

Ejercicio Utilizando Listas Simples 2

1.    Crear una lista simple enlazada de número enteros, se desea añadir un nodo entre dos nodos consecutivos; el dato del nuevo nodo debe ser la diferencia en valor absoluto de los dos nodos.

Ejemplo si tengo la siguiente lista

 |   20   |   |   43   |  |   17   |  |   4    |  |    11   |

Se dese insertar un dato entre 43 y 17.

Reviso que exista la secuencia

Luego calculo el valor absoluto de (43-17)

Inserto entre esos elementos.

 |   20   |   |   43   |  |   26  |  |   17   |  |   4    |  |    11   |

Para el ejercicio propuesto se tiene que analizar que se debe tener un método en especial que realiza la resta y el valor absoluto de ambos números, como también la inserción de este nuevo digito en medio de los dos. Para esto debemos hacer uso del usuario el cual de como referencia el inicio del número a ser restado por el siguiente, por lo que se le pedirá al usuario el ingreso del número. De esta manera fácilmente realizamos los requerimientos planteados.

Main:

import java.util.Scanner;

public class Main 
{

 public static void main(String[] args) 
 {
  Scanner leer=new Scanner(System.in);
  Lista arreglo = new Lista();
   
   arreglo.agregarInicio(17);
   arreglo.agregarFin(4);
   arreglo.agregarFin(1);
   arreglo.agregarFin(6);
   arreglo.agregarFin(8);
   
   System.out.println("\nLista Ingresada ");
   arreglo.imprimir();
   
   System.out.println("\nIngrese el numero de referencia de inicio para insertar el nuevo valor: ");
   int numero;
   numero=leer.nextInt();
   
   arreglo.insertarValorAbsoluto(numero);
   
   System.out.println("\nLista Ingresada modificada ");
   arreglo.imprimir();

 }

}

Lista:

public class Lista
{
 private Nodo inicio;
 private Nodo fin;
 
 public Lista()
 {
  inicio=fin=null;
 }
 
 public void agregarInicio(int info)
 {
  Nodo nuevo = new Nodo(info,inicio);
  
  if(inicio==null)
  {
   inicio=fin=nuevo;
  }
  
  inicio=nuevo;
  
 }
 
 public void agregarFin(int info)
 {
  Nodo nuevo=new Nodo(info, null);
  
  if (inicio==null)
  {
   inicio=fin=nuevo;
  }
  
  else
  {
   fin.setSiguiente(nuevo);
   fin=nuevo;
   
  }
 }
 
 public void imprimir()
 {
  Nodo aux=inicio;
  while(aux!=null)
  {
   System.out.println(aux.getDato());
   aux=aux.getSiguiente();
  }
 }
 
 public void eliminarNodo(int info)
 {
  if(inicio!=null)
  {
   if(inicio==fin&&inicio.getDato()==info)
   {
    inicio=fin=null;
   }
   else
   {
    if(inicio.getDato()==info)
    {
     inicio=inicio.getSiguiente();
    }
    else
    {
     Nodo anterior=inicio;
     Nodo siguiente=inicio.getSiguiente();
     
     while(siguiente!=null&&siguiente.getDato()!=info)
     {
      anterior=siguiente;
      siguiente=siguiente.getSiguiente();
     }
     
     if(siguiente!=null)
     {
      anterior.setSiguiente(siguiente.getSiguiente());
      if(siguiente==fin)
      {
       fin=anterior;
      }
     }
    }
   }
  }
 }
 

 public int[] obtenerDato()
 {
  Nodo recorre = inicio;
  int dato[]=new int  [6];
  
  
  for(int i=0;i<dato.length;i++)
  {
   dato[i] = recorre.getDato();   
   recorre = recorre.getSiguiente();
  }
  return dato;

 }
 
 
 public void insertarValorAbsoluto (int buscar)
 {
  Nodo aux=inicio;
  
  while (aux!=null)
  {
   
   
   if(aux.getDato()==buscar)
   {
    insertar(aux,aux.getSiguiente());
    return;
   }
   
   aux=aux.getSiguiente();
  }
  
 }
 
 public void insertar (Nodo aux, Nodo aux2)
 {
  Nodo nuevo=new Nodo(Math.abs(aux.getDato()-aux2.getDato()));
  aux.setSiguiente(nuevo);
  nuevo.setSiguiente(aux2);
 }

}
 

Nodo:

public class Nodo 
{
 private int dato;
 private Nodo siguiente;
 
 public Nodo (int dato)
 {
  this.dato=dato;
  this.siguiente=null;
 }
 
 public Nodo (int dato, Nodo siguiente)
 {
  this.dato=dato;
  this.siguiente=siguiente;
 }

 public int getDato() {
  return dato;
 }

 public void setDato(int dato) {
  this.dato = dato;
 }

 public Nodo getSiguiente() {
  return siguiente;
 }

 public void setSiguiente(Nodo siguiente) {
  this.siguiente = siguiente;
 }
 
 

}

Ejecucion en consola:

Ejercicio Utilizando Listas Simples

1.    Crear una lista simple la cual debe ingresar números reales, luego ordenarlos de mayor a menor, imprimir la lista, obtener el promedio de los valores de cada lista, comprobar cuál es el valor que más se repite en la lista. 

Para este ejercicio es fundamental conocer que cuando se trabaja con listas simples, no es posible recorrer en ambos sentidos (atrás-delante), simplemente en una sola dirección. Por lo que en el ejercicio se usó un método para almacenar los datos en un arreglo y de esta manera organizarlos mediante el método que más nos agrade, en este caso el ordenamiento burbuja.

A continuación el código fuente:

Main:

import java.util.Scanner;

public class Main
{

 public static void main(String[] args) 
 {
  Lista arreglo = new Lista();
  Scanner leer = new Scanner(System.in);
  
  System.out.println("\t\t\tBienvenido al Programa Listas\n");
  
  int numero=5,dato;
  

  for (int i = 0; i < numero; i++) 
  {
   System.out.println("\nIngrese el dato de el nodo "+(i+1));
   dato=leer.nextInt();
   
   arreglo.agregarInicio(dato);
   
  }
  
  System.out.println("Lista Ingresada: ");
  arreglo.imprimir();

  System.out.println("Lista Ingresada ordenada Mayor Menor ");
  arreglo.ordenarMayorMenor(numero);
  
  System.out.println();
  arreglo.sacarPromedio();
  
  System.out.println();
  arreglo.sacarMayorRepeticiones(numero);

 }

}

Lista

public class Lista 
{
 private Nodo inicio;
 private Nodo fin;
 
 public Lista()
 {
  inicio=fin=null;
 }
 
 public void agregarInicio(int info)
 {
  Nodo nuevo = new Nodo(info,inicio);
  
  if(inicio==null)
  {
   inicio=fin=nuevo;
  }
  
  inicio=nuevo;
  
 }
 
 public void agregarFin(int info)
 {
  Nodo nuevo=new Nodo(info, null);
  
  if (inicio==null)
  {
   inicio=fin=nuevo;
  }
  
  else
  {
   fin.setSiguiente(nuevo);
   fin=nuevo;
   
  }
 }
 
 public void imprimir()
 {
  Nodo aux=inicio;
  while(aux!=null)
  {
   System.out.println(aux.getDato());
   aux=aux.getSiguiente();
  }
 }
 
 public void eliminarNodo(int info)
 {
  if(inicio!=null)
  {
   if(inicio==fin&&inicio.getDato()==info)
   {
    inicio=fin=null;
   }
   else
   {
    if(inicio.getDato()==info)
    {
     inicio=inicio.getSiguiente();
    }
    else
    {
     Nodo anterior=inicio;
     Nodo siguiente=inicio.getSiguiente();
     
     while(siguiente!=null&&siguiente.getDato()!=info)
     {
      anterior=siguiente;
      siguiente=siguiente.getSiguiente();
     }
     
     if(siguiente!=null)
     {
      anterior.setSiguiente(siguiente.getSiguiente());
      if(siguiente==fin)
      {
       fin=anterior;
      }
     }
    }
   }
  }
 }
 
 public void ordenarMayorMenor(int d)
 {
  int aux;
  Nodo recorre1=inicio;
  int datos[]=new int [d];
  
  for(int i=0;i<d;i++)
  {
   datos[i]=recorre1.getDato();
   recorre1=recorre1.getSiguiente();
   
  }
  
  for(int k=0;k<d-1;k++)
  {
   for(int j=k+1;j<d;j++)
   {
    if(datos[k]<datos[j])
    {
     aux=datos[k];
     datos[k]=datos[j];
     datos[j]=aux;     
    }
    
   }
  }  
  Lista nueva =new Lista();
  
  for(int f=0;f<d;f++)
  {
   nueva.agregarFin(datos[f]);
  }
   nueva.imprimir();
  
 }
 
 public void sacarPromedio()
 {
  Nodo aux=inicio;
  double promedio=0, promFinal=0;
  int cont=0;
  while(aux!=null)
  {
   promedio=promedio+aux.getDato();
   aux=aux.getSiguiente();
   cont++;
  }
  
  promFinal=promedio/cont;
  System.out.println("El Promedio de los numeros igresados es: "+promFinal);
 }
 
 public void sacarMayorRepeticiones(int d)
 {
  int frecuenciaTemp, frecuenciaModa = 0, moda = -1;;
  Nodo recorre1=inicio;
  int datos[]=new int [d];
  
  for(int i=0;i<d;i++)
  {
   datos[i]=recorre1.getDato();
   recorre1=recorre1.getSiguiente();
   
  }
    
   for (int i=0; i < datos.length-1; i++)
   {
             frecuenciaTemp = 1;
             for(int j = i+1 ; j< datos.length; j++)
             {
                 if(datos[i] == datos[j])
                     frecuenciaTemp ++;                
             }
             if(frecuenciaTemp > frecuenciaModa)
             {
                 frecuenciaModa = frecuenciaTemp;
                 moda = datos[i];
             }
         }
         System.out.println("El elemento que mas se repite es: " + moda + "\nY su frecuencia: " + frecuenciaModa);        
 
 }
  
}

Nodo:

public class Nodo 
{
 private int dato;
 private Nodo siguiente;
 public Nodo(int dato, Nodo siguiente) 
 { 
  this.dato = dato;
  this.siguiente = siguiente;
 }
 
 public Nodo(int dato)
 {
  this.dato = dato;
  this.siguiente = null;
  
 }
 public int getDato() 
 {
  return dato;
 }

 public void setDato(int dato) 
 {
  this.dato = dato;
 }

 public Nodo getSiguiente() 
 {
  return siguiente;
 }

 public void setSiguiente(Nodo siguiente) 
 {
  this.siguiente = siguiente;
 }

}

Ejecución en consola

                                           

Diferencias entre Pilas y Colas

Pilas VS Colas:

Pilas: 

Las pilas son muy útiles en varios escenarios de programación. Dos de los más comunes son:

• Pilas que contienen direcciones de retorno: 
  Si un método llama a otro método "return", el comportamiento LIFO de la pila asegura que la instrucción del segundo método transfiere la ejecución al primer método, y la del primer método transfiere la ejecución al código que sigue al código que llamó al primer método. Como resultado una pila "recuerda" las direcciones de retorno de los métodos llamados.

• Pilas que contienen todos los parámetros del método llamado y las variables locales: 
  Cuando se llama a un método, la JVM reserva memoria cerca de la dirección de retorno y almacena todos los parámetros del método llamado y las variables locales de ese método. Si el método es un método de ejemplar, uno de los parámetros que almacena en la pila es la referencia del objeto actual.

Normalmente se trabaja con dos tipos de colas: lineal y circular. En ambas colas, la inserción de datos se realiza en el fin de la cola, se mueven hacia adelante y se recuperan/borran del inicio de la cola.

Las colas son muy útiles en varios escenarios de programación, entre los que se encuentran:

• Temporización de Threads: 
  Una JVM subyacente podrían establecer varias colas para coincidir con diferentes prioridades de los threads. La información del thread se bloquea porque todos los threads con una prioridad dada se almacenan en una cola asociada.

• Trabajos de impresión: 
  Como una impresora normalmente es más lenta que un ordenador, un sistema operativo maneja los trabajos de impresión en un subsistema de impresión, que inserta esos trabajos de impresión en una cola. El primer trabajo en esa cola se imprime primero, y así sucesivamente.

Ambas son estructuras de almacenamiento, que nos ayudan a guardar información de una manera práctica y sencilla, el uso de las mismas depende del usuario y del tema a ser trabajado.

Vídeos Relacionados:

 REFERENCIAS BIBLIOGRÁFICAS:

Programacion-basica. (2013). "Listas y Pilas en java". recuperado el 17 de noviembre de 2015 de https://sites.google.com/site/programacionbasicajava/listas-pilas-y-colas

Colas en Java

Una cola es simplemente un lugar para almacenar elementos, donde esas elementos se insertan una detrás de otra y para extraer siempre se lo hace por adelante de la cola donde se encuentra el primer elemento.

Una cola puede almacenar lo que nosotros queramos, números, personas, documentos, cualquier cosa. . Como se puede observar su funcionamiento es similar a la de las listas, por lo que se está familiarizado con el uso.

En Java podemos encontrar variadas formas de crear Colas, nos enfocaremos en una de sus Interfaces que tiene como nombre “Queue” con la cual podemos crear Colas y que contiene los siguientes métodos para el uso de las mismas.

·         Para Insertar:
add(elemento)
offer(elemento)

·         Para Extraer:
remove()
poll()

·         Para Consultar el Frente:
element()
peek()

Al igual que la interfaz “Queue” existe otro tipo de clae llamada LinkedList que utiliza los mismos métodos, que nuestra clase “Queue”.

Ejemplo:

Para usar colas realizaremos un ejemplo sencillo en el cual utilizaremos métodos previamente estudiados de nuestra clase LinkedList. Se puede notar que se pueden almacenar diferentes datos, en nuestro caso almacenaremos enteros, decimales y cadenas de caracteres, con lo que se puede concluir, que es muy práctico el uso de esta estructura.

import java.util.LinkedList;

public class Cola 
{

 public static void main(String[] args) 
 {
  
  LinkedList cola=new LinkedList();
  
        cola.offer(3);
        cola.add(4);
        cola.offer(12);
        cola.add(6);
        cola.add("hola");
        cola.offer(11);
        cola.add(1111.2);
        cola.add("lola");
        
        System.out.println("Elementos de la cola: " + cola);
    
  
 }

}

Ejemplo en consola:

Videos relacionados:

Pilas en Java

Una pila básicamente es una estructura que nos permite apilar elementos y recopilarlos en el orden inverso al cual los vamos apilando mediante operaciones de des-apilar. Su estructura es LIFO (Last In First Out) que quiere decir que el ultimo proceso apilado , sera el primero en salir. Esta estructura tiene 3 operaciones básicas:

• Apilar (push): añade un elemento a la lista.
• Desapilar (pop): retira un elemento de la lista
• Peek: consulta el primer elemento de la cima de la pila
• Empty: comprueba si la pila está vacía.
• Search: busca un determinado elemento dentro de la pila y devuelve su posición dentro de ella.
• Condición: ¿está vacía la pila de datos?: comprueba si la lista está vacía

Para la utilización de esta estructura en el lenguaje Java contamos con la clase Stack en la librería java.util.

Para dar un ejemplo de una pila utilizaremos un ejercicio sencillo el cual consiste en ingresar 10 elementos, que en este caso van a ser enteros, mediante el método push de la clase pila. Además se va a extraerlos mediante el método pop de la misma clase.

Nota: se transforman los elementos enteros a tipo "string" para almacenarlos.

Ejemplo:

import java.util.Stack;
public class Main 
{
 public static void main(String[] args) 
 {
  Stack pila = new Stack();
  for(int i=0;i<10;i++)
  {
   pila.push(Integer.toString(i));
  }
  while(!pila.empty())
  {
   System.out.println(pila.pop());
  }
 }
}

Ejemplo en consola:

Conclusiones:

El uso de pilas es una manera muy práctica de almacenamiento, que lleva muchas ventajas consigo así como la facilidad de aplicación de sus métodos, en este caso colocar elementos en una pila (push) como también sacarlos (pop) y mostrarlos en consola. 

Vídeos Explicativos: