Estructura de Datos: abril 2014

miércoles, 30 de abril de 2014

Listas enlazadas

/**
* @(#)ListaSimple.java
*               Programa para trabajar con Listas Enlazadas
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/4/28
*/

  import java.util.Scanner;

class Nodo {
int elemento;
Nodo siguiente;

public Nodo(int x)
{
   elemento=x;
   siguiente=null;
}
}
public class ListaSimple {

    /**
     * Creates a new instance of <code>ListaSimple</code>.
     */

    private static Nodo frente=null, fin=null;

    public ListaSimple() {
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int opcion;
        Scanner ent=new Scanner(System.in);

                 // Presentamos el menú de opciones a trabajar con lista
        do
        {
        System.out.println(" ");
        System.out.println("---------------------------------------------");
        System.out.println("Programa para manejo de Lista Enlazada Simple");
         System.out.println("---------------------------------------------");
        System.out.println("              1.- Insertar                           ");
        System.out.println("              2.- Eliminar                         ");
        System.out.println("              3.- Presentar                         ");
        System.out.println("              4.- Limpiar                           ");
        System.out.println("              5.- Salir                               ");
        System.out.println("---------------------------------------------");
        System.out.println(" ");

        opcion=ent.nextInt();

        switch(opcion)
        {
          case 1: insertar();
            break;
            case 2: eliminar();
               break;
          case 3: presentar();
            break;
          case 4: limpiar();
                 break;
          case 5: break;

          default: System.out.println("Opcion Equivocada");
            break;
            }
        } while(opcion!=5);
    }
             //    Método para INSERTAR UN ELEMENTO
public static void insertar()
{
    int valor;
Nodo aux;
Scanner ent=new Scanner(System.in);

System.out.print("Ingrese elemento: ");
valor=ent.nextInt();

aux=new Nodo(valor);

if(frente==null)
  frente=aux;
else
   fin.siguiente=aux;
fin=aux;
}

           //    Método para PRESENTAR LOS ELEMENTOS
public static void presentar()
{ Nodo aux;
if (frente==null)
  System.out.println(" !!! Lista Vacia!!!");

  else
   for(aux=frente; aux!=null;)
   {
   System.out.println("Presentando elemento: "+aux.elemento);
   aux=aux.siguiente;
   }
}
         //    Método para ELIMINAR UN ELEMENTO
    public static void eliminar()
  {
        if(frente==null)
          System.out.println(" !!! Lista Vacia!!!");
        else{
           System.out.println("Eliminando elemento: "+frente.elemento);
          frente=frente.siguiente;
         }
    }

         //    Método para LIMPIAR LISTA

public static void limpiar()
{
    if (frente==null)
   System.out.println(" !!! Lista Vacia!!!");
    else
   for(frente=frente; frente!=null;)
   {
   System.out.println("Limpando elemento: "+frente.elemento);
   frente=frente.siguiente;
   }
}
}

martes, 29 de abril de 2014

Colas en Java

/**
* @(#)Colas.java
*
*   Programa para trabajar con una cola.
*   Especificamos el tamaño de la cola.
*   Solicitamos el ingreso de elementos a la Cola.
*   Podemos eliminar un elemento de la Cola.
*   Podemos mostrar los elementos que contiene la Cola.
*   Podemos borrar completamente el contenido de la Cola.
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/4/7
*/
import java.util.Scanner;

public class Colas {

    /**
     * Creates a new instance of <code>Pilas</code>.
     */
    public Colas() {
    }

public static int frente=0, Fin=0;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

      int [] cola;
    int max=0;
    int opcion=0;

    Scanner ent=new Scanner (System.in);

            // TODO code application logic here

        System.out.println("     Ingrese el tamaño de la Cola ");
        max=ent.nextInt();
        cola=new int[max];

        do {
        System.out.println(" ______________________________________");
        System.out.println("|                                      |");
        System.out.println("|    Programa para trabajos en Colas   |");
        System.out.println("|______________________________________|");
        System.out.println("     1.- Ingresar elemento en Cola     ");
        System.out.println("     2.- Eliminar elemento de Cola     ");
        System.out.println("     3.- Presentar elementos de Cola   ");
        System.out.println("     4.- Limpiar Cola                  ");
        System.out.println("     5.- Salir                         ");
        System.out.println("_______________________________________");

        opcion=ent.nextInt();

        switch(opcion)

        {
        case 1: insertar(cola,max);
           break;
        case 2: eliminar(cola);
           break;
        case 3: presentar(cola);
           break;
        case 4: frente=0;
           Fin=0;
           break;
        case 5: break;

        default:
          System.out.println("Opcion equivocada");
        }

    } while (opcion!=5);

   }

// metodo para ingresar datos en cola

public static void insertar(int[]c, int m)
{
Scanner ent=new Scanner(System.in);

if (Fin < m)                // verificando cola llena
{   Fin++;                     // incrementamos el valor de fin para mostrar en pantalla

  System.out.println("Ingrese elemento <<"+Fin+">> de la Cola");
  c[Fin-1]=ent.nextInt(); // restamos a Fin 1 para dejarlo como estaba antes de mostrar
                                      // y solicitamos la entrada del elemento
  if (Fin==1)                   // si final = 1
  {
   frente=Fin;                 // ponemos el mismo valor a frente
  }
}
  else
  {
   System.out.println("Desbordamiento de Cola");
  }
}

public static void eliminar(int[]c)
{
if (frente>Fin || Fin==0)     // validacion de valores de frente y final de la cola
{
   System.out.println("Cola Vacia");
}
  else
  {
   System.out.println("Eliminando el elemento "+frente);
   System.out.println("c["+frente+"]="+c[frente-1]); // mostrando el valor a eliminar de la cola
   frente++;
  }
}

public static void presentar(int[]c)
{
   if (frente>Fin || Fin==0) // validacion de valores de frente y final de la cola
   {
     System.out.println("Cola Vacia ");    // mensaje de cola vacia
    }
      else
   {
      for(int i=frente; i<=Fin; i++) // leemos todos los elementos de la cola
    {
        System.out.println("Cola ["+i+"]"+c[i-1]);   // se muestran en pantalla los elementos de la cola
       }
   }
  }
}

Cola Circular

/**
* @(#)ColaCircular.java
*
*  Programa para el manejo de una cola circular,
*  donde especificamos el tamaño de la cola,
*  insertamos los elementos de la tabla, se valida
*  que no se desborde la tabla, que la cola no este
*  llena.
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/4/11
*/
import java.util.Scanner;
public class ColaCircular {

    /**
     * Creates a new instance of <code>ColaCircular</code>.
     */
    public ColaCircular() {
    }

    /**
     * @param args the command line arguments
     */

    public static int frente=0, fin=0;          // se definen las variables requeridas

    public static void main(String[] args)
    {
        // TODO code application logic here

          int max, opcion;
          int [] colacir;

        Scanner ent=new Scanner(System.in);

        System.out.println("Tamaño de la Cola ");
        max=ent.nextInt();
        colacir=new int[max];

        fin = max - 1;
  frente = siguiente(fin,max);

        do
        {
   System.out.println("Programa para manejo de Cola Circular");
            System.out.println("-------------------------------------");
        System.out.println("         1.- Insertar ");
        System.out.println("         2.- Extraer ");
        System.out.println("         3.- Presentar");
        System.out.println("         4.- Limpiar ");
        System.out.println("         5.- Salir    ");
        System.out.println("-------------------------------------");
        System.out.println(" ");

        opcion=ent.nextInt();

        switch(opcion)
        {
          case 1: insertar(colacir, max);
            break;
           case 2: elimina(colacir, max);
            break;
          case 3: presentar(colacir, max);
            break;
          case 4: fin = max - 1;
            frente = siguiente(fin,max);
            break;
          case 5: break;

          default: System.out.println("Opcion Equivocada");
            break;
            }
        } while(opcion!=5);
    }

    public static int siguiente(int ptr, int max)
    {
    return (ptr+1) % max;        // % significa igual a modulo
    }

//    Método para INSERTAR UN ELEMENTO
    public static void insertar(int[]c, int max)
    {
    Scanner ent = new Scanner(System.in);
      if(frente==siguiente(siguiente(fin,max),max))
       System.out.println("        !!!DESBORDAMIENTO DE COLA!!!!      ");
     else{
        fin = siguiente(fin,max);
        System.out.print("Ingrese elemento <<"+fin+">> de la cola :");
        c[fin] = ent.nextInt();
      }
    }
//    Método para ELIMINAR UN ELEMENTO
    public static void elimina(int []p, int max)
  {
        if(frente==siguiente(fin,max))
          System.out.println(" !!! COLA VACIA!!!");
        else{
          System.out.println("Eliminando el elemento <<"+frente+">> = "+p[frente]);
        frente=siguiente(frente,max);
         }
    }
//    Método para PRESENTAR LOS ELEMENTOS DE UNA COLA CIRCULAR
public static void presentar(int []p, int m)

{
     for (int i=frente; i!=siguiente(fin,m);i++)
   System.out.println("Cola["+i+"] = "+p[i]);
    }
}

miércoles, 9 de abril de 2014

Trabajos con Pilas

/**
* @(#)Pilas.java
*
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/4/7
*/
// Programa para trabajar con Pilas

import java.util.Scanner;

public class Pilas {

/**
* Creates a new instance of <code>Pilas</code>.
*/
public Pilas() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

// declaramos las variables requeridas

int n, opcion, cima=0;

int [] pila;

Scanner ent=new Scanner (System.in);

// TODO code application logic here

// solicitamos en pantalla el tamaño de la pila

System.out.println("Ingrese el tamaño de la Pila");
n=ent.nextInt();
pila=new int[n];

// solicitamos en pantalla el numero de opcion a realizar

do {
System.out.println("Programa para trabajos en Pilas");
System.out.println("__________________________________");
System.out.println(" 1.- (Push) Ingresar dato ");
System.out.println(" 2.- (Pop) Retirar Dato ");
System.out.println(" 3.- Presentar Pila ");
System.out.println(" 4.- Limpiar Pila ");
System.out.println(" 5.- Salir ");
System.out.println("__________________________________");

opcion=ent.nextInt();

// mediante un switch hacemos la tarea solicitada

switch(opcion)

{
case 1: cima=push(pila,cima); // colocamos un valor en la pila
break;
case 2: cima=pop(pila,cima); // quitamos un valor de la pila
break;
case 3: presentar(pila,cima); // presentamos los valores de la pila
break;
case 4: cima=0; // borramos en contenido de la pila
break;
case 5: break;

default:
System.out.println("Opcion equivocada");
}

} while (opcion!=5);
}
// metodo para ingresar datos en pila

public static int push(int[]p, int c)

{ Scanner ent=new Scanner(System.in);
if (c <p.length)
{
c++;
System.out.println("Ingrese elemento "+c+":");
p[c-1]=ent.nextInt();
}
else
{
System.out.println("¡¡¡ PILA LLENA");
System.out.println("elimina elemento..");
}
return c;
}
// metodo para quitar datos de la pila

public static int pop(int[]p, int c)
{
if (c!=0)
{
System.out.println("Se elimino el elemento"+c+"= "+p[c-1]);
c--;
}
else
{
System.out.println("¡¡¡ PILA SIN DATOS");
}
return c;
}
// metodo para presentar los datos de la pila

public static void presentar(int[]p, int c)
{
if (c!=0)

{ System.out.println("Mostrando datos de pila");

for(int i=c-1; i>=0; i--)
{
System.out.println("Elemento "+i+":"+p[i]);
}

}
else
{
System.out.println("PILA VACIA ");
}

}
}

Variables Simples y Compuestas

/**
* @(#)Variables.java
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/3/28
*/
// Programa para mostrar las variables simples y compuestas

public class Variables {

/**
* Creates a new instance of <code>Variables</code>.
*/
public Variables() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

// se declaran las variables necesarias

int entero;
float flotante;
byte bait;
double doble;
long largo;
char caracter;

// Se declara el arreglo y se asignan valores a las variables

char[] arreglo={'H','O','L','A'};
String cadena="Cadena de caracteres";

entero=12;

flotante=1;
bait=0x00;
largo=1200000;
caracter='A';
doble=1000000.1000000;

// se muestran el valor de las variables Simples en pantalla

System.out.println("........Variables SIMPLES..........");
System.out.print("Esto es un INT : "+entero+" ++entero ; ");
System.out.println(entero++);
System.out.println("Esto es un FLOAT : "+flotante);
System.out.println("Esto es un BYTE : "+bait);
System.out.println("Esto es un LONG : "+largo);
System.out.println("Esto es un CHAR : "+caracter);
System.out.println("Esto es un DOUBLE : "+doble+"\n");

// se muestran el valor de las variables Compuestas en pantalla

System.out.println("........Variables COMPUESTAS.......");
System.out.println("Esto es un STRING : "+cadena);
System.out.println("Esto es el elemento 0 de ARREGLO : "+arreglo[0]);
System.out.println("Esto es el elemento 3 de ARREGLO : "+arreglo[3]);
System.out.println("Esto es la posicion de memoria donde inicia ARREGLO : "+arreglo);

}
}

Ordenar Arreglos

/**
* @(#)OrdenadoArreglo.java
*
*
* @author Ricardo Camacho Lamas
*
* @version 1.00 2014/4/7
*/
import java.util.Scanner; // librerias necesarias

public class OrdenadoArreglo {
/**
* Creates a new instance of <code>OrdenadoArreglo</code>.
*/
public OrdenadoArreglo() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
// TODO code application logic here

// declaracion de variables necesarias

int []Arreglo;
int longitud;

Scanner lectura = new Scanner(System.in);
System.out.println(" Programa para ordenar un Arreglo");
// longitud del arreglo
System.out.print("Ingrese la Cantidad de Elementos del arreglo : ");
longitud = lectura.nextInt();
// Creando un arreglo de tamaño longitud
Arreglo = new int[longitud];

leerdatos(Arreglo); // se llama al metodo para leer datos
datosdesorden(Arreglo); // se llama al metodo para mostrar los datos como se ingresaron
datosenorden (Arreglo); // se llama al metodo para mostrar los datos ya ordenados
}
public static void leerdatos(int []a)
{
Scanner lectura = new Scanner(System.in);

// Leer todos los numero a ordenar

System.out.println("Ingresar - " + a.length + " - elementos : ");
for(int i=0; i<a.length ; i++)
{
a[i] = lectura.nextInt();
}
}
public static void datosdesorden(int[] a)
{
// Mostra el arreglo desordenado

for(int i=0; i<a.length ; i++)
System.out.print(a[i]+" ");
System.out.println(" ");
}
public static void datosenorden(int[] a)
{
int aux;
// Ordenar los Numeros utilizando el metodo Burbuja

for(int i=0; i<a.length-1 ; i++ )
for(int j=i+1 ; j <a.length ; j++)
if(a[j]<a[i])
{
// Intercambiar los valores

aux = a[j];
a[j] = a[i];
a[i] = aux;
}
// Mostra el arreglo ordenado

for(int i=0; i<a.length; i++)
System.out.print(a[i]+" ");
}
}

Arreglos Multidimensionales

/**
* @(#)ArregloMultidimencional.java
*
* @author Ricardo Camacho Lamas
*
* @version 1.00 2014/4/4
*/
import java.util.Scanner; // librerias necesarias

public class ArregloMultidimencional { // clase publica

/**
* Creates a new instance of <code>ArregloMultidimencional</code>.
*/
public ArregloMultidimencional() { // constructor
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

int[][]x; // declaracion de arreglo mutidimencional
int n, m;
Scanner ent=new Scanner(System.in);

System.out.print("Ingrese numero de renglones : ");
n=ent.nextInt();
System.out.print("Ingrese numero de columnas : ");
m=ent.nextInt();
x=new int[n][m];
leerdatos(x);
presentar(x);

}

public static void leerdatos(int[][]a)
{
Scanner ent=new Scanner(System.in);

System.out.println("Ingreses los datos ");

for(int i=0; i<a.length; i++)
{
for(int j=0; j<a[i].length; j++)
{
System.out.print("a["+i+"]["+j+"]=");
a[i][j]=ent.nextInt();
}
}
}

public static void presentar(int[][]a)
{
for(int i=0; i<a.length; i++) //recorrido de la cantidad de renglones
{
for(int j=0; j<a[i].length; j++) //recorrido de la cantidad de columnas
{
System.out.print(a[i][j]+" ");
}
System.out.println();

}
}
}

Programa de arreglos unidimensionales (Numero Menor, Mayor y Promedio)

/**
* @(#)ArregloUni.java
*
* @author Ricardo Camacho Lamas
*
* Programa de arreglos unidimensionales
*
* @version 1.00 2014/4/2
*/
import java.util.Scanner;

public class ArregloUni {

/**
* Creates a new instance of <code>ArregloUni</code>.
*/
public ArregloUni() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

//declara variables y arreglo

int n;
int [] x;

Scanner entrada = new Scanner(System.in);

System.out.println("Tamaño del arreglo");
n = entrada.nextInt();
x = new int[n];
System.out.println("Arreglo creado de "+n+ " posiciones");

// entrada de datos del arreglo

for (int i=0; i<n; i++)
{
System.out.print("elemento x["+i+"]=");
x[i]=entrada.nextInt();
}

// salida de datos del arreglo

for (int i=0; i<n; i++)
{
System.out.println("x["+i+"]="+x[i]);
}

// mostrar el elemento mayor y el elemento menor

int menor=0, mayor=0;

for (int i=0; i<n; i++)

if (i==0)
{
menor=x[i];
mayor=x[i];
}
else
{
if (x[i]<menor)
menor=x[i];
if (x[i]>mayor)
mayor=x[i];
}

System.out.println("Menor = "+menor);

System.out.println("Mayor = "+mayor);

// Calculo de la suma de los elementos para sacar promedio

double suma=0, promedio=0;

for (int i=0; i<n; i++)
{
suma=suma+x[i];
}
promedio=(suma/n);

System.out.println("El promedio es : "+ promedio);

}
}

Calculo de area a cuadrado, circulo, rectangulo y triangulo con objetos en Java.

/**
* @(#)AreasObjetos.java
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/3/31
*/

/*
* Programa para calculo de area de Cuadrado, rectangulo, triangulo y circulo.
*/
public class AreasObjetos {

/**
* Creates a new instance of <code>AreasObjetos</code>.
*/
public AreasObjetos() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

// se definien las variables necesarias a utilizar

int lado = 4;
int l1 = 5, l2 = 6;
double radio = 7;
int base = 8, altura = 9;
double pi = 3.141621;

Area area=new Area ();

// se muestra las area mandando llamar al objeto

System.out.println("Area del cuadrado: "+ area.cuadrado (lado)+"\n");

System.out.println("Area del triangulo: "+ area.triangulo (base, altura));

System.out.println("Area del rectangulo: "+ area.rectangulo (l1, l2));

System.out.println("Area del circulo : "+ area.circulo (radio, pi));

}
}
// calculo del area de las figuras geometricas

class Area {
public Area(){
}
public int cuadrado (int lado)
{
int ret;
ret = lado * lado;
return ret;
}

public int triangulo (int base, int altura)
{
int tri;
tri = (base*altura)/2;
return tri;
}

public int rectangulo (int l1, int l2)
{
int rec;
rec = (l1 * l2);
return rec;
}

public double circulo (double radio, double pi)
{
double cir;
cir = (radio * radio)* pi;
return cir;
}
}

Programa que calcula el area de triangulo, rectangulo, cuadrado y circulo en Java.

/**
* @(#)Areas.java
*
* @author Ricardo Camacho Lamas
* @version 1.00 2014/3/29
*/

/**
* Programa para calcular el area de:
* triangulo, cuadrado, rectangulo, circulo
*/
public class Areas {

/**
* Creates a new instance of <code>Areas</code>.
*/
public Areas() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

// se definen las variables necesarias

int base;
int altura;
float areat;

int lado1;
int lado2;
float arear;

int ladoc;
float areac;

double radio;
double pi;
double areacc;

// calculo de area del triangulo

base = 5;
altura = 15;
areat = (base*altura)/2;

System.out.println("........AREA DE UN TRIANGULO........."+"\n");
System.out.println("La base del triangulo tiene un valor de : "+base+"\n");
System.out.println("La altura del triangulo tiene un valor de : "+altura+"\n");
System.out.println("El area del triangulo tiene un valor de : "+areat+"\n");

// calculo de area del rectangulo

lado1 = 5;
lado2 = 8;
arear = lado1*lado2;

System.out.println("........AREA DE UN RECTANGULO........."+"\n");

System.out.println("El lado1 tiene un valor de : "+lado1+"\n");
System.out.println("El lado2 tiene un valor de : "+lado2+"\n");
System.out.println("El valor del Area es de : "+arear+"\n");

// calculo de area del cuadrado

ladoc = 5;
areac = ladoc*ladoc;

System.out.println("........AREA DE UN CUADRADO.........."+"\n");

System.out.println("El lado tiene un valor de : "+ladoc+"\n");
System.out.println("El valor del Area es de : "+areac+"\n");

// calculo de area del circulo

radio = 10;
pi = 3.141621;
areacc = pi*(radio*radio);

System.out.println("..............AREA DE UN CIRCULO.............."+"\n");
System.out.println("El radio del circulo tiene un valor de : "+radio+"\n");
System.out.println("El area del circulo tiene un valor de : "+areacc+"\n");

}
}