Capturas de pantalla de la ejecución de los programas.

Ejecución ejercicio1

Ejecución ejercicio2

Ejercicio2

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






import javax.swing.JOptionPane;



public class Ejercicio2 {

 public static void main(String[] args) 
 {
 Lista Lista1= new Lista();
  
  Lista1.agregarInicio(17);
  Lista1.agregarInicio(43);
  Lista1.agregarInicio(20);
  Lista1.agregarFin(4);
  Lista1.agregarFin(11);
  System.out.println("Lista inicial");
  Lista1.imprimir();
  
  int agregar = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número anterior al nuevo a ingresar"));
  
  Lista1.agregarNodo(agregar);

  System.out.println("Lista con el nuevo número:");
  Lista1.imprimir();

 

public class Nodo 
{

 //Declaración de atributos
 private int numero;
 private Nodo siguiente;
 
 //Constructor Nodo null
 public Nodo(int numero)
 {
  this.numero=numero;
  this.siguiente=null;
 }
 //Constructores
 public Nodo(int numero, Nodo siguiente)
 {
  this.numero=numero;
  this.siguiente=siguiente;
 }

 //Métodos get y set de la clase Nodo
 public int getNumero() {
  return numero;
 }

 public void setNumero(int numero) {
  this.numero= numero;
 }

 public Nodo getSiguiente() {
  return siguiente;
 }

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








public class Lista 
{

 private Nodo inicio;
 private Nodo fin;
 
 public Lista()
 {
  inicio=fin=null;
 }
 
 //Método que permite agregar un elemento al inicio de la lista
 public void agregarInicio(int info)
 {
  Nodo nuevo=new Nodo(info, inicio);
  if( inicio == null)
  {
   Inicio = fin = nuevo;
  }
  Inicio = nuevo;
 }
 
 //Método que permite agregar un elemento al fin de la lista
 public void agregarFin(int info)
 {
  Nodo nuevo=new Nodo(info, null);
  if ( inicio == null)
  {
   inicio=fin=nuevo;
  }
  else
  {
   fin . setSiguiente(nuevo);
   fin = nuevo;
  }
 }
 
 //Método  que permite  imprimir los elementos de la lista
 public void imprimir()
 {
  Nodo aux=inicio;
  while(aux!=null)
  {
   System.out.println(aux.getNumero());
   aux=aux.getSiguiente();
  }
 }


//Método que permite eliminar el nodo
 public void eliminarNodo(int num)
 {
  if(inicio!=null)
  {
   if((inicio==fin)&&(inicio.getNumero()==num))
   {
    inicio=fin=null;
   }
   else if(inicio.getNumero()==num)
   {
    inicio=inicio.getSiguiente();
   }
   else
   {
    Nodo anterior=inicio;
    Nodo siguiente=inicio.getSiguiente();
    while((siguiente!=null)&&(siguiente.getNumero()!=num))
    {
     anterior=siguiente;
     siguiente=siguiente.getSiguiente();
    }
    if(siguiente!=null)
    {
     anterior.setSiguiente(siguiente.getSiguiente());
     if(siguiente==fin)
     {
      fin=anterior;
     }
    }
   }
  }
 }
 
 //Metodo aue permite agregar un nuevo  nodo
 public void agregarNodo(int num)
 {
  if(inicio!=null)
  {
   if(inicio==fin && inicio.getNumero()==num)
   {
    inicio=fin=null;
   }
   else if(inicio.getNumero()==num)
   {
    inicio = inicio.getSiguiente();
   }
   else
   {    
    Nodo anterior = inicio;
    Nodo siguiente = inicio.getSiguiente();   
    while(siguiente!=null && anterior.getNumero()!=num)
    {

    anterior = siguiente;
    siguiente = siguiente.getSiguiente();

    }
    if (siguiente!=null)
    {
     Nodo nuevo = new Nodo(calculo(anterior.getNumero(),siguiente.getNumero()),siguiente);
     
     anterior.setSiguiente(nuevo);

     nuevo.setSiguiente(siguiente);

     if(siguiente == fin)
     {
      fin = anterior;
     }
    }
   }  
  }
 }


 //Método que permite calcular el valor absoluto entre números ubicados en nodos.
 public int valAbs(int primer, int segundo)
 {
  int num = primer -segundo;   
  num =Math.abs(num);
  return num;  
 }

}

?

Ejercicio1

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ejercicio1;

import java.util.Scanner;

/**
 *
 * 
 */
public class Ejercicio1 {


    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        Scanner entrada=new Scanner(System.in);
 Lista array=new Lista();
 
        int numero=5,dato;
   
 
        for (int i = 0; i < numero; i++) 
        {
        System.out.println("\nIngrese el elemento" +(i+1)+ "de la lista");
        numero=entrada.nextInt();
    
        
    
        array . agregarInicio(numero);
 }
        //Se invoca al método imprimir para que muestre la lista
 System.out.println("Datos ingresados");
 array.imprimir();
 
 System.out.println("\nLista ordenada en forma descendente");
 array.ordenar(n);
 
 array.promedio();}}



public class Nodo {
    
    //atributos de la clase NODO
    private int numero;
     private Nodo siguiente;

     //constructor con parámetros
    public Nodo(int numero, Nodo siguiente) {
        this.numero = numero;
        this.siguiente = siguiente;
    }
    
    //constructor con Nodo siguiente apuntado a null
      public Nodo(int numero) {
        this.numero = numero;
        this.siguiente = null;
    }

      
      //Métodos GEtters y setters de la clase Nodo
    public int getNumero() {
        return numero;
    }

    public void setNumero(int numero) {
        this.numero = numero;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

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



public class Lista {
    
    //atributos de la clase Lista
    private Nodo inicio;
    private Nodo fin;
 
 public Lista()
 {
  inicio=fin=null;
 }
 
 //Metodo que permite agregar un numero al inicio
 public void agregarInicio(int info)
 {
  Nodo nuevo=new Nodo(info, inicio);
  if(inicio==null)
  {
   inicio=fin=nuevo;
  }
  inicio=nuevo;
 }

 //Metodo que permite agregar un numero al fin
 public void agregarFin(int info)
 {
  Nodo nuevo=new Nodo(info, null);
  if(inicio==null)
  {
   inicio=fin=nuevo;
  }
  else
  {
   fin.setSiguiente(nuevo);
   fin=nuevo;
  }
 }

        //Metodo para los datos de la lista
 public void imprimir()
 {
  Nodo aux=inicio;
  while(aux!=null)
  {
   System.out.println(aux.getNumero());
   aux=aux.getSiguiente();
  }
 }


 //Metodo  que permite ordenar de forma descendente la lista
 public void ordenar(int info)
 {
  int aux;
  Nodo recorrer=inicio;
  int array[]=new int [info];

               for (int i = 0; i < info; i++)
               {
   array[i]=recorrer.getNumero();
   recorrer=recorrer.getSiguiente();
  }

               for (int k = 0; k < info; k++){

                    for (int j=k+1; j < info; j++){

                       if(array  [k]  <  array [j]){


{
     aux = array [ k ];
     array [ k ] = array [ j ];
     array [ j ]= aux;
    }
   }
  }

                Lista nueva=new Lista();
  for (int f = 0; f < info ; f ++)
  {
   nueva . agregarFin (array [ f ]);
  }
  nueva.imprimir();
 }
 

//Método que permite calcular el promedio de los elementos de la lista
 public void promedio()
 {
  Nodo aux=inicio;
  int suma=0;
  double promedio;
  while(aux!=null)
  {
   suma= suma+ aux.getNumero();
   aux=aux.getSiguiente();
  }
  promedio=suma/6;
  System.out.println("El promedio de los elementos de la lista es:"+promedio);
 }
    
}
                       

?

Colas en Java (ejercicio manejo de colas)

package colasjava;

/**
 *
 * @author JV PC LDU
 */
public class COLASJAVA {

    /**
     * @param args the command line arguments
     */
    
      public static void main(String[] args) {
        Cola cola = new Cola(4);
        cola.print();
        cola.remove();
        cola.insert("Hola");
        cola.insert(2);
        cola.insert("java");
        cola.insert(9);
        cola.insert(8888);
        cola.remove();
        cola.remove();
        cola.remove();
        cola.remove();
        cola.remove();
    }
    
}

CLASE COLA


public class Cola {
    private Object[] cola;
    private int frente;
    private int fin;
    
    public Prueba(int tamanio)
    {
        cola = new Object[tamanio];
        frente = fin = -1;
    }
    
    public boolean isEmpty()
    {
        return frente == fin;
    }
    
    public boolean isFull()
    {
        return fin == cola.length-1;
    }
    
    
    public void insert(Object elemento)
    {
        if(isFull())
            System.out.println("La cola esta llena, elimine datos!");
        else
            cola[++fin] = elemento;
    }
    
    public Object remove()
    {
        if(isEmpty())
        {
            System.out.println("La cola esta vacia, inserte datos!");
            return "Cola vacia";
        }
        else
            return cola[++frente];
    }
    
    
    public void print()
    {
        if(isEmpty())
            System.out.println("La cola esta vacia!");
        else if(frente == -1)
        {
            for(int i = 0; i <= fin; i++)
            {
                System.out.println(cola[i]);
            }
        }
        else
        {
            for(int j = frente; j <= fin; j++)
            {
                System.out.println(cola[j]);
            }
        }
    }

}

?

Programa Funcionamiento de Pilas en Java

package pilas;

import java.util.Stack;

/**
 *
 * @author JV PC LDU
 */
public class Pilas {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Stack Pila=new Stack();
        
        //push se utiliza para ingresar un dato en la pila
        Pila.push(100);  // va a ser el índice 0  
        Pila.push(90); // va a ser el índice 1  
        Pila.push(80);  // va a ser el índice 2  
        Pila.push(70); // va a ser el índice 3  
        Pila.push("en Pilas de JAVA ");  // va a ser el índice 4
        Pila.push("ciertas operaciones ");  // va a ser el índice 5 
        Pila.push("el funcionamiento de ");  // va a ser el índice 6 
        Pila.push("Se muestra");  // va a ser el índice 7
        Pila.push("En el siguiente programa:");  // va a ser el índice 8
       
       //observando los datos ingresados se muestra claramente la
        //característica LIFO (last in, first out (último en entrar, primero en salir)
        
  
        //como se puede observar en el código superior, en las pilas podemos insertar    
        //todo tipo de datos, en este caso Strings y enteros.
        
        
        //peek() método nativo de la clase stack para observar el último dato de la pila.
        System.out.println("El último elemento introducido en la pila es: "+Pila.peek());
         System.out.println("");
         System.out.println("");
         do{
             
             //pop()método nativo de la clase stack para imprimir los datos de la pila.
             System.out.println(Pila.pop());
         }while(Pila.empty()==false);
         
         
    }
    
}

?

Comparación entre Pilas y Colas (JAVA)

 PILAS Y COLAS COMPARACIÓN

Las pilas y colas tienen cosas en común tales como su implementación y ciertas operaciones que permiten manejar a cada una de ellas, pero también tienen diferencias fundamentales que van a ser redactadas en la siguiente tabla:

JAVA
DIFERENCIAS FUNDAMENTALES ENTRE PILAS Y COLAS.
PILAS	COLAS
En las pilas, se puede acceder a los elementos de las listas sólo a través de la cima de la misma.	En las colas, se pueden acceder a los elementos de las listas por los dos extremos (inicial y final)
En las pilas, los elementos se eliminan de la manera ( last in, first out) es decir el último que entra es el primero que sale.	En las colas, los elementos se eliminan en el orden de llegada.
Las pilas son consideradas estructuras de datos LIFO (last in, first out)	Las colas son consideradas estructuras de datos FIFO (first in, first out)
En las pilas solo se pueden agregar elementos por la cima.	En las bicolas se pueden agregar elementos por dos extremos (fin, inicio)

Colas en Java

Las colas de Java son estructuras de datos que almacenan elementos de una Lista y permiten acceder acada uno de ellos por los dos extremos  de la lista.

Los elementos de la cola se añaden por la parte final de la lista y se eliminan por la parte inicial de la lista tal y como se muestra en la siguiente imagen:

A diferencia de las Pilas , en las colas de Java los elementos se eliminan en el orden en el que se almacenan , debido a esto es considerada una estructura FIFO (first in ,first out).

Las operaciones necesarias para el manejo de colas son las siguientes:

• Tipo de dato-----Elemento que se almacena en una cola.

Operaciones

• CrearCola-----Inicia la cola como vacía
• Insertar-----inserta un elemento en la cola.
• Quitar-----quita un elemento de la cola.
• Cola vacía-----Comprueba si la cola está vacía.
• Cola llena-----Comprueba si la cola está llena.
• Frente-----obtiene el elemento frente de la cola
• Tamaño de la cola-----Número máximo de elementos que puede contener la cola.

Para implementar una cola se pueden utilizar arreglos estáticos, vectores y listas enlazadas, pero utilizar arreglos tiene un problema "el de avance lineal" (deja huecos por el lado izquierdo del arreglo) tal y como se muestra en la siguiente imagen:

Clasificación de las Colas en Java:

Las colas se clasifican según su forma de implementación.

Colas Circulares

Este tipo de colas se caracterizan por estar formadas por un arreglo circular el cual hace que la forma de almacenar los datos sea más eficiente, ya que al unirse el extremo final y el extremo cabeza del arreglo permite que todas las posiciones del arreglo sean ocupadas. 

Arreglos circulares que permiten la creación de las "Colas circulares"

Colas de prioridad

Son colas de estructura lineal en la cual los elementos se insertan en cualquier posición de la cola y se eliminan solamente por el frente (FIFO).

Colas Bicola

Son colas de estructura lineal en las que los elementos se pueden agregar o eliminar por cualquier extremo de la cola. También son llamadas colas bidireccionales.

Colas Simples

Son colas de estructura lineal en las que los elementos salen en el mismo orden en el que llegan.