martes, 29 de abril de 2014

Cola circular

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;
   
    public static void main(String[] args) {
        // TODO code application logic here
      int max, opcion;
      int [] colacirc;
      Scanner ent=new Scanner(System.in);
      System.out.print("Tamaño de la cola");
      max=ent.nextInt();
      colacirc=new int[max];
      do
      {
      System.out.print("1) Insertar");
      System.out.print("2) Eliminar");
      System.out.print("3) Presentar");
      System.out.print("4) Limpiar");
      System.out.print("5) Salir");
      opcion=ent.nextInt();
      switch (opcion)
         {
     
      case 1 : Insertar(colacirc, max);
      break;
      case 2 : Eliminar (colacirc, max);
      break;
      case 3 : Presentar(colacirc, max);
      break;
      case 4 : frente=0;
              fin=max;
      case 5 : break;
      default : System.out.println("Opción equivocada");
      break;
         }      
        } while(opcion !=5);
    }
   
     public static int siguiente(int posicion, int m)
     {
      return (posicion+1) % m;
     }
     
     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 Eliminar(int []c, int max)
    {
     if(frente==siguiente(fin,max))
      System.out.println(" !!! COLA VACIA!!!");
     else{
      System.out.println("Eliminando el elemento <<"+frente+">> = "+c[frente]);
      frente=siguiente(frente,max);
     }
    }
    //Método para PRESENTAR LOS ELEMENTOS DE UNA COLA CIRCULAR

    public static void Presentar(int []c, int max){
   
     for(int i=frente; i!=siguiente(fin,max); i=siguiente(i,max))
       System.out.println("Cola["+i+"] = "+c[i]);
     
     }
    }

La cola circular a diferencia de la cola simple, nos permite de manera contínua y finita ingeresar y eliminar elementos, tantos como se haya declarado un arreglo, los espacios se puedes reutilizar constantemente.

Colas

import java.util.Scanner;
public class Cola {
       
    /**
     * Creates a new instance of <code>Cola</code>.
     */
    public Cola() {
    }
    public static int frente=0, fin=0;
    /**
     * @param args the command line arguments
     */
     
    public static void main(String[] args) {
        // TODO code application logic here
        int max, opcion;
        int [] cola;
        Scanner  ent=new Scanner(System.in);
        System.out.print("Tamano de la cola:");
        max=ent.nextInt();
        cola=new int[max];
       
        do {
       
        System.out.println("1)Insertar en cola");
        System.out.println("2)Eliminar elemento");
        System.out.println("3)Presentar cola");
        System.out.println("4)Limpiar cola");
        System.out.println("5)Salir");
        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("Opción equivocada");
        }      
        } while (opcion !=5);
     }
       
     public static void insertar(int[]c, int m)
        {
        Scanner ent=new Scanner(System.in);
        if (fin<m)
        {
           System.out.print("ingrese valor:");
        c[fin]=ent.nextInt();
        fin++;
        if(fin==1)
        {
        frente=fin;
        }
        }
        else
        {
        System.out.println("!!!DESBORDAMIENTO DE COLA ");
            }
       
        }
        public static void eliminar(int[]c)
        {
       
        if(frente>fin||fin==0)
        {
        System.out.println("!!!COLA SIN DATOS");
        }
        else
        {
        System.out.println("eliminando elemento"+frente);
        System.out.println("c["+frente+"]="+c[frente-1]);
        frente++;
        }
       
        }
       
        public static void presentar (int []c)
        {
         if (frente>fin||fin==0)
        {
        System.out.println("COLA VACIA");
        }
        else
        {
        for(int i=frente;i<=fin; i++)
        {
        System.out.println("cola["+ i +"]"+c[i-1]);
        }
       
          }
       
        }
     
}

La particularidad de una estructura de datos de cola es el hecho de que sólo podemos acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.

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) {
        // TODO code application logic here
               
        int n, opcion, cima=0;
        int [] pilas;
        Scanner  ent=new Scanner(System.in);
        System.out.print("Tamano de la pila:");
        n=ent.nextInt();
        pilas=new int[n];
       
        do {
       
        System.out.println("1)Push");
        System.out.println("2)Pop");
        System.out.println("3)Presentar Pila");
        System.out.println("4)Limpiar Pila");
        System.out.println("5)Salir");
        opcion = ent.nextInt();
        switch (opcion)
        {
        case 1: cima=push(pilas,cima);
        break;
        case 2: pop(pilas, cima);
        break;
        case 3: presentar(pilas,cima);
        break;
        case 4: cima=0;
        break;
        case 5: break;
        default:
        System.out.println("Opcion equivocada");
        }      
        } while (opcion !=5);
     }
       
     public static int push(int[]p, int c)
        {
        Scanner ent=new Scanner(System.in);
        if (c<p.length)
        {
        c++;
        System.out.print("ingrese elemento "+c+":");
        p[c-1]=ent.nextInt();
        }
        else
        {
        System.out.println("!!!PILA LLENA");
        System.out.println("elimine un elemento");
        }
        return c;
        }
        public static int pop(int[]p,int c)
        {
        Scanner ent=new Scanner(System.in);
        if(c!=0)
        {
        System.out.println("Se elimino el elemento"+c+"= "+p[c-1]);
        c--;
        }
        else
        {
        System.out.println("!!!PILA SIN DATOS");
        }
        return c;
       
        }
        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");
        }
        }
         
}

Una pila es una lista ordenada de datos en la que el modo de acceso a sus elementos es el último en entrar, primero en salir que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de la informática debido a su simplicidad y ordenación implícita de la propia estructura.

jueves, 10 de abril de 2014

Programa método de la burbuja

import java.util.Scanner;
public class ArregloOrdenado {  
    /**
     * Creates a new instance of <code>ArregloOrdenado</code>.
     */
    public ArregloOrdenado() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
     
        int n;
        int [] x;
        Scanner entrada = new Scanner (System.in);
        System.out.print("Tamaño del arreglo\n");
        n=entrada.nextInt();
        x=new int [n];
        leedatos(x);
        muestradatos(x);
        ordenadatos(x);        
}
    public static void leedatos(int[]a)
    {
    Scanner ent=new Scanner (System.in);
    for (int i=0; i<a.length; i++)
    {
   
    System.out.print("Ingresa elemento a["+i+"]");
    a[i]=ent.nextInt();
    }
   
    }
public static void muestradatos(int []a)
{
for (int i=0; i<a.length; i++)
{
System.out.println("Muestra datos a["+i+"]"+a[i]);
}
}
// ordenamiento con el método de la burbuja
public static void ordenadatos(int[ ]a)
{
             int aux;
for(int i = 0; i < a.length; i++)
{
for (int j = i + 1; j < a.length; j++){
if(a[j]< a[i]){
aux = a[i];
a[i]=a[j];
a[j]=aux;
                 
                     }
            }          
        }
        System.out.println("El arreglo ordenado es: ");
                    for (int i = 0; i < a.length; i++)
                    {              
                    System.out.println("En forma ascendente a["+i+"]="+a[i]);
                    }
                   
         }
       
}

Este es un programa de arreglo que nos muestra los datos ingresados al programas y nos los ordena de manera ascendente con el método de la burbuja, el cual de manera muy sencilla nos permite realizar la acción de ordenar con un mínimo de código, para el caso de ordenar en forma descendente, solo será necesario cambiar el símbolo de menor a mayor. El método de la burbuja utiliza un auxiliara para almacenar los datos de manera provisional para escalar los datos que serán movidos para se ordenados de acuerdo a necesidad del usuario.

Arreglo multidimensional

import java.util.Scanner;
public class ArregloMultidimensional {
       
    /**
     * Creates a new instance of <code>ArregloMultidimensional</code>.
     */
    public ArregloMultidimensional() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int [][]x;
        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("Ingrese 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++)
    {
   
for(int j=0; j<a[i].length; j++ )
{
System.out.print(a[i][j]+ "  ");
}
System.out.println();
}
    }
}

Este es un programa arreglo de dos dimensiones, es decir, mediante índices nos permite conocer la ubicación de un elemento dentro del arreglo, razón por la que desde el main se declaran dos variables y doble corchete en una misma variable para indicar que se trata de un arreglo bidimensional.

Arreglo con instrucciones desde el main

public ArregloVersion2() {
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n;
        int [] x;
        Scanner entrada = new Scanner (System.in);
        System.out.print("Tamaño del arreglo");
        n=entrada.nextInt();
        x=new int [n];
        leedatos(x);
        muestradatos(x);
        
        System.out.println("el menor es: "+menor(x));
        System.out.println("el mayor es: "+mayor(x));
        System.out.println("el promedio es: "+promedio(x));
    }    
    
    public static void leedatos(int[]a)
    {
    Scanner ent=new Scanner (System.in);
    for (int i=0; i<a.length; i++)
    {
    
    System.out.print("Ingresa elemento a["+i+"]");
    a[i]=ent.nextInt();
    }
    
    }
 public static void muestradatos(int []a)
 {
 for (int i=0; i<a.length; i++)
 {
 System.out.println("Muestra datos a["+i+"]"+a[i]);
 }
 }
 public static int menor (int[]a)
 {
  int min= a[0];
  for (int i=0; i< a.length; i++)
  { 
  if (a[i]<min)
   min=a[i];
  }
  return min;
 } 
 public static int mayor (int[]a)
 {
  int may= a[0];
  for (int i=0; i< a.length; i++)
  {
  if (a[i]>may)
   may=a[i];
  }
  return may;
    }
    public static double promedio (int[]a)
    {
        double prom=0, suma=0;     
     for (int i=0; i<a.length; i++)
         
      suma+=a[i];
      prom=(suma/a.length);
    
     return prom;
    
    } 
}


En este programa desde el main se declaran las variables y el código para realizar las operaciones o acciones deseadas mediante la sentencia for en donde esta sentencia me permite repetir n veces un ciclo, en donde se debe determinar  el valor inicial y cuantas veces se va a repetir. Así no es necesario repetir tanto código, lo anterior aunado a lo práctico que es un arreglo con "n" posiciones, minimizando la cantidad de código a escribir. Desde el main se declara la acción a ejecutar.

Arreglo

public ArregloUni() {
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n;
        int [] x;
        Scanner entrada = new Scanner (System.in);
        System.out.print("Tamaño del arreglo");
        n=entrada.nextInt();
        x=new int [n];
        System.out.println ("Arreglo creado de "+n+ "posiciones");
        
        for (int i=0; i<n; i++)
        {
        
         System.out.print("Elemento x["+i+"]=");
         x[i]= entrada.nextInt();
        }
        for (int i=0; i<n; i++)
        {
         System.out.println("x["+i+"]="+x[i]);
        
        
        }  
        // Mostrar el elemento menor y elemento mayor
        
        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);
      double suma=0, promedio=0;
      for (int i=0; i<n; i++)
      {
        suma=suma +x[i];
        promedio=(suma/n);
      }
     System.out.print("El promedio es:"+promedio);    
}
}


Este es un programa de array o arreglo que nos permite almacenar un "n" número de datos sin necesidad de extender el código de un programa y mediante métodos específicos, podemos realizar las operaciones deseadas con solo definir en el método la cantidad de posiciones que se deseen en el arreglo y solicitar nos indique cual de los elemento es el menor, mayor o el promedio de ellos.

Programa para calcular áreas

import matematicas.*;
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
        int lado = 4;
        int L1=5, L2=6;
        int radio=7;
        int base=8, altura=9;
        double pi=3.1416;
        pi=3.1416;
        Area area=new Area();
        System.out.println("Area del cuadrado:"+ area.cuadrado (lado));
        System.out.println("Area del triángulo:"+ area.triángulo (base,altura));
        System.out.println("Area del rectángulo:"+ area.triángulo (L1,L2));
        System.out.println("Area del círculo:"+ area.círculo (radio,pi));
    }
 }

Este es un programa que nos permite calcular áreas de diferentes figuras geométricas, para realizar los cálculos sólo basta con asignar valores a las variables de acuerdo a las necesidades, ejemplo: si deseamos conocer el área de un círculo, solo debemos asignar un valor al radio que ha sido declarado y compilar para correr el programa, el mismo nos dará el resultado de esa figura si es la única que fue modificada, y así con cada figura de la que deseemos conocer su área.

Programa para calcular áreas con métodos por separado

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
        int lado = 4;
        int L1=5, L2=6;
        int radio=7;
        int base=8, altura=9;
        double pi=3.1416;
         pi=3.1416;
        Area area=new Area();
        System.out.println("Area del cuadrado:"+ area.cuadrado (lado));
        System.out.println("Area del triángulo:"+ area.triángulo (base,altura));
        System.out.println("Area del rectángulo:"+ area.triángulo (L1,L2));
        System.out.println("Area del círculo:"+ area.círculo (radio,pi));
    }
    
    
}

 class Area {
     public Area (){
     }
     public int cuadrado (int lado){
      int ret;
      ret = lado*lado;
      return ret;
     }
     public int triángulo ( int base, int altura){
    
      int tri;
      tri = (base*altura)/2;
      return tri;
     }
      public int rectángulo ( int L1, int L2){
    
      int rec;
      rec = (L1*L2);
      return rec;
      }
     
     public double círculo ( double radio,double pi){
    
      double cír;
      cír = pi*(radio*radio);
      return cír;
      }
 }

Este programa al igual que el anterior, nos permite realizar cálculos de figuras geométricas, con la particularidad de que desde el main quedan anidadas todas las variables, los métodos han sido declarados por separado, quedando más compactos.

Programa calcula áreas desde un paquete

import matematicas.Area;
import java.util.Scanner;
public class Figurasgeometricas {
       
    /**
     * Creates a new instance of <code>Figurasgeometricas</code>.
     */
    public Figurasgeometricas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        int sel, lado, l1, l2, base, altura, radio;
        System.out.println("=====Programa para calcular áreas geométricas=====");
        Scanner entrada=new Scanner(System.in);
        Area area=new Area();
       
        do{
       
        System.out.print("Elija una opcion:\n 1 cuadrado\n 2 rectángulo\n 3 triángulo\n 4 círculo\n 0 salir\n");
        sel = entrada.nextInt();
        System.out.println("Usted seleccionó:"+sel);
        sel=entrada.nextInt();
        switch (sel){
         case 1: System .out.print("ingresa el lado");
                 lado=entrada.nextInt();
                 System.out.print("el área="+area.cuadrado(lado));
                 break;
         case 2: System.out.print("lado 1:");
           l1=entrada.nextInt();
           System.out.println("\n lado 2:");
           l2=entrada.nextInt();
           System.out.println("el area="+area.rectángulo(l1,l2));
           break;
         case 3: System.out.print("base:");
           base=entrada.nextInt();
           System.out.println("\n altura:");
           altura=entrada.nextInt();
           System.out.println("el area="+area.triángulo(base,altura));
           break;
         case 4: System.out.print("radio:");
           radio=entrada.nextInt();
           System.out.println("el area="+area.círculo(radio,radio));
           break; 
         case 0:break;
         default: System.out.print("te equivocaste de opción");
         break;
        
        }
                 
    }while(sel!=0);
}

}

Este programa se ejecuta con una sentencia de iteración en donde primeramente se ejecuta la sentencia y luego se evalúa la condición. Si la expresión de la condición es verdadera vuelve a dar un ciclo. De lo contrario, lo termina, esto nos garantiza que la sentencia se ejecute al menos una vez; de igual manera que el programa inmediato anterior, para realizar los cálculos, invoca al paquete de métodos matemáticas creado por separado para la realización de los mismos, paquete que contiene las operaciones para realizar los cálculos.

Programa Paquete matemáticas

package matematicas;
public class Area {

    public Area() {
    }
    public int cuadrado (int lado){
     int ret;
      ret = lado*lado;
      return ret;
    }
    public int triángulo ( int base, int altura){
    
      int tri;
      tri = (base*altura)/2;
      return tri;
     }
    public int rectángulo ( int L1, int L2){
    
      int rec;
      rec = (L1*L2);
      return rec;
      }
    public double círculo ( double radio,double pi){
    
      double cír;
      cír = pi*(radio*radio);
      return cír;
      }    
}

Este es un paquete de métodos que puede ser invocado desde otro programa como el antes visto inmediatamente atrás, este tipo de programas nos permite realizar operaciones con n mínimo de código en el programa del que dispondrá el usuario.

import matematicas.*;
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
        int lado = 4;
        int L1=5, L2=6;
        int radio=7;
        int base=8, altura=9;
        double pi=3.1416;
         pi=3.1416;
        Area area=new Area();
        System.out.println("Area del cuadrado:"+ area.cuadrado (lado));
        System.out.println("Area del triángulo:"+ area.triángulo (base,altura));
        System.out.println("Area del rectángulo:"+ area.triángulo (L1,L2));
        System.out.println("Area del círculo:"+ area.círculo (radio,pi));
    }
 }

Este es un programa paquete que los cálculos u operaciones necesarias para el cálculo de áreas geométricas desde un programa externo, desde el cual se invoca a este paquete para el cálculo, así nuestro programa es mas compacto.

miércoles, 9 de abril de 2014

Programa cálculo de áreas

public class Calculodeareas {
       
    /**
     * Creates a new instance of <code>Calculodeareas</code>.
     */
    public Calculodeareas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
               
        System.out.println ("Programa para calcular el área de un cuadrado\n");
        int lado;
        double area;
        lado = 8;
        area = lado*lado;
        System.out.println("........AREA DE UN CUADRADO.........."+"\n");
        System.out.println("El lado tiene un valor de : "+lado+"\n");
        System.out.println("El valor del Area es de : "+area);
        System.out.println ("Programa para calcular el área de un rectángulo\n");
        float base;
        float altura;
        base = 5;
        altura = 8;
        area = base*altura;
        System.out.println("La base tiene un valor de : "+base+"\n");
        System.out.println("La altura tiene un valor de : "+altura+"\n");
        System.out.println("El valor del Area es de : "+area);
       
        System.out.println ("Programa para calcular el área de un triángulo\n");
         float b,h;              
        b = 8;
        h = 12;
        area = b*h/2;
        System.out.println("La base tiene un valor de : "+b+"\n");
        System.out.println("La altura tiene un valor de : "+h+"\n");
        System.out.println("El valor del Area es de : "+area);
        System.out.println ("Programa para calcular el área de un círculo\n");
      
       double pi;
       double radio;
        radio = 5;
       pi = 3.1416;
       area = pi*(radio*radio);
       System.out.println("El valor del Area es de : "+area);
    }
}

Este programa nos permite realizar el cálculo de áreas de figuras específicas como son el cuadrado, rectángulo, triángulo y círculo; sin importar los valores numéricos de las figuras.