Manejo de Matrices en Java

martes, 26 de abril de 2011 0 comentarios

Ingresar datos por teclado

package ingresarteclado;
import java.io.*;
/**
 *
 * @author Reynaldo
 */
public class IngresarTeclado {
   
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
        BufferedReader Leer = (new BufferedReader(new InputStreamReader(System.in)));
       
        int v[] = new int[4] ;
       
        for(int i = 0 ; i < v.length ; i++){
            System.out.print("Ingrese un Numero: ");
            v[i] = Integer.parseInt(Leer.readLine());
        }
        for(int i = 0 ; i < v.length ; i++){
            System.out.print(" " + v[i]);
        }
        System.out.println();
    }
}

Mostrar datos ingresados por teclado

package mostrardatos;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author Reynaldo
 */
public class MostrarDatos {

    public static void Mostrar(int x[]){
        for(int i = 0 ; i < x.length ; i++){
            System.out.println("[" + i + "]" + x[i]);
        }
    }
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
       
        //MostrarDatos Most = new MostrarDatos();
       
       
        BufferedReader Leer = (new BufferedReader(new InputStreamReader(System.in)));
       
        int v[] = new int[4] ;
       
        for(int i = 0 ; i < v.length ; i++){
            System.out.print("====================\n");
            System.out.print("Ingrese un Numero: ");
            v[i] = Integer.parseInt(Leer.readLine());
        }
        System.out.print("====================\n");
        System.out.print("\n********************\n");
        System.out.print("Datos Ingresados\n");
        System.out.print("********************\n");
        Mostrar(v);
   }
}






Mostrar elementos de un Vector con la Clase Vector

package mostrarconlaclasevector;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Vector;

/**
 *
 * @author Reynaldo
 */
public class MostrarConLaClaseVector {

    public static void Mostrar(Vector x){
        for(int i = 0 ; i < x.size() ; i++){
            System.out.println("[" + i + "]" + x.get(i));
        }
    }
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
       
       
        BufferedReader Leer = (new BufferedReader(new InputStreamReader(System.in)));
       
        Vector v = new Vector();
       
           
            v.addElement("Uno");
            v.addElement("Dos");
            v.addElement("Tres");
            v.addElement("Cuatro");
            v.addElement("Cinco");
            v.addElement("Seis");
            v.addElement("Siete");
            v.addElement("Ocho");
            v.addElement("Nueve");
            v.addElement("Diez");
           
           
            Mostrar (v);  
   }
}



Ordenacion (Metodo - Burbuja)

package metodoburbuja;
import java.util.Scanner;
//Este Algoritmo fue ejecutado bajo JDK 7.0 y Netbeens 7.0
/**
 *
 * @author Reynaldo
 */
public class MetodoBurbuja {

    public static void main(String[] args) {

        int v[] = new int[5];
        int t;
       
        Scanner teclado = new Scanner(System.in);
       
        for(t = 0 ; t < v.length ; t++){
            System.out.print("Ingrese un Numero:");
            v[t] = teclado.nextInt();
        }
       
            for(int i = 0 ; i < v.length ; i++){
                for(int j = 0 ; j < v.length ; j++){
                    //cambiando el signo de menor a mayor podemos ordenar de
                    //forma descendente y de mayor a menor en forma ascendente
                    if(v[i] < v[j]){
                      int aux = v[i];
                         v[i] = v[j];
                         v[j] = aux;
                    }
                   
                }
            }
            for(int i = 0 ; i < v.length; i++)
                System.out.print("  "+v[i]);
                System.out.println();
        }
     }



Algoritmo de Busqueda Secuencial (Busqueda - Lista)

package algoritmobusqueda;

/**
 *
 * @author Reynaldo
 */
public class AlgoritmoBusqueda {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n = 10;
        String amigos[] = new String[n];
        String nombre = "romina";//en esta linea colocamos el nombre a buscar
       
        //Lista de amigos
        amigos[0] = "rocio";
        amigos[1] = "romina";
        amigos[2] = "chenda";
        amigos[3] = "nancho";
        amigos[4] = "oscar";
        amigos[5] = "gilfredo";
        amigos[6] = "reynaldo";
        amigos[7] = "daniel";
        amigos[8] = "javier";
        amigos[9] = "gilka";
       
        //Ubicar amigo
        int p = - 1;
        for(int i = 0 ; i < n ; i++){
            if(amigos[i].equals(nombre)){
                p = i;
                break;
            }
        }
        //imprimir lista de amigos
        System.out.println("Lista de Amigos\n");
        for(int j = 0 ; j < amigos.length ; j++)
            System.out.println("\t" + amigos[j]);
        //Imprimir resultado
        if(p == -1)
            System.out.println(" \n " + nombre + " no Existe en la Lista");
        else
            System.out.println(" \n " + nombre + " Esta en la Posicion " + p);
    }
}
 





Algoritmo de Busqueda Binaria (Busqueda - Binaria)

package busquedabinaria;
import java.util.Scanner;

/**
 *
 * @author Reynaldo
 */
public class BusquedaBinaria {

    public static void Buscar(int v[],int elem){
       
        int pos = - 1;
       
        for(int i = 0 ; i < v.length ; i++){
            if(v[i] == elem){
                pos = i;
            }
        }
        System.out.println("Elemento el la Posicion [" + pos + "]");
    }
  
   
    public static void main(String[] args) {
        // TODO code application logic here
        int v1[] = new int[5];
        int elem = 0;
       
        Scanner teclado = new Scanner(System.in);
       
        for(int i = 0 ; i < v1.length ; i++){
            System.out.print("Ingrese un Numero: ");
            v1[i] = teclado.nextInt();
        }
      
        System.out.println("Ingrese el Numero a Bucar: ");
        elem = teclado.nextInt();
       
        Buscar(v1 , elem);
       
    }
       
 }


En este ejemplo se muestra como ordenar un vector de números enteros generados de forma aleatoria en el rango del 1 al 20 utilizando en método clone hacemos una copia de la lista en la lista2.

public class ClonarVector {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        int n = 5;
        int lista[] = new int[n];
        int lista2[];
       
        //Generar Lista
        for(int k = 0 ; k < n ; k++)
            lista[k] = (int) (Math.random() * 20 + 1);
       
        //Sacar una Copia de la Lista en la Lista2
        lista2 = lista.clone();
       
        //Ordenar Lista - Metodo Burbuja
        for(int i = 0 ; i < (n - 1) ; i++){
            for(int j = i + 1 ; j < n ; j++){
                if(lista2[i] < lista2[j]){
                    int temp = lista2[i];
                    lista2[i] = lista2[j];
                    lista2[j] = temp;
                }
            }
        }
        //Imprimir Lista Ordenada
        System.out.println("Lista Generada\t Lista Ordenada");
        for(int f = 0 ; f < n ; f++)
            System.out.println("\t"+ lista[f] + "\t\t" + lista2[f]);
           
    }
}



En este ejemplo tenemos una lista de amigos, de lo que se trata de ubicar la poscion de uno de ellos, para lo cual ingresaremos el nombre del amigo a buscar en la línea de comando como parámetro

public class AlgoritmoBusqueda {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n = 10;
        String amigos[] = new String[n];
        String nombre = "romina";//en esta linea colocamos el nombre a buscar
       
        //Lista de amigos
        amigos[0] = "rocio";
        amigos[1] = "romina";
        amigos[2] = "chenda";
        amigos[3] = "nancho";
        amigos[4] = "oscar";
        amigos[5] = "gilfredo";
        amigos[6] = "reynaldo";
        amigos[7] = "daniel";
        amigos[8] = "javier";
        amigos[9] = "gilka";
       
        //Ubicar amigo
        int p = - 1;
        for(int i = 0 ; i < n ; i++){
            if(amigos[i].equals(nombre)){
                p = i;
                break;
            }
        }
        //imprimir lista de amigos
        System.out.println("Lista de Amigos\n");
        for(int j = 0 ; j < amigos.length ; j++)
            System.out.println("\t" + amigos[j]);
        //Imprimir resultado
        if(p == -1)
            System.out.println(" \n " + nombre + " no Existe en la Lista");
        else
            System.out.println(" \n " + nombre + " Esta en la Posicion " + p);
    }
}





Se lee por teclado 5 numeros por teclados 5 para el vector A y 5 para el vector B luego se procede a comparar cuantos elementos de A se encuentran en B.

public class VectoresDeAenB {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        int c = 0;
        int a[] = new int[5];
        int b[] = new int[5];
       
        Scanner teclado = new Scanner(System.in);
       
        System.out.println("====================================");
        for(int f = 0 ; f < a.length ; f++){
            System.out.print("Ingrese un Numero para Vector a: ");
            a[f] = teclado.nextInt();
        }
        System.out.println("====================================");
        for(int g = 0 ; g < b.length ; g++){
            System.out.print("Ingrese un Numero para Vector b: ");
            b[g] = teclado.nextInt();
        }
       
        for(int i = 0 ; i < a.length ; i++){
            for(int j = 0 ; j < b.length ; j++){
                if(a[i] == b[j])
                    c += 1;
            }
        }
        System.out.println("====================================");
        System.out.println("Cantidad: " + c);
        System.out.println("====================================");
    }
}


Matrices

Este ejemplo se trata de la suma de matrices, para lo cual es necesario que ambas matrices tengan las misma dimensiones.
Las Matrices se generan de forma aleatoria. Para imprimir se a creado el método sayMatriz, que se encarga de imprimir lo que se le pasa como parámetro.

package sumarmatrices;

/**
 *
 * @author Reynaldo
 */
public class SumarMatrices {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int mat1[][] = new int[4][5];
        int mat2[][] = new int[4][5];
        int suma[][] = new int[4][5];
       
        //Generar matriz 1
        for(int i = 0 ; i < mat1.length ; i++)
            for(int j = 0 ; j < mat1[i].length ; j++)
                mat1[i][j] = (int)(Math.random() * 20 + 10);
           
        for(int i = 0 ; i < mat2.length ; i++)
            for(int j = 0 ; j < mat2[i].length ; j++)
                mat2[i][j] = (int)(Math.random() * 20 + 10);
       
        //Calcular la Suma
        for(int i = 0 ; i < mat2.length ; i++)
            for(int j = 0 ; j < mat2.length ; j++)
                suma[i][j] = mat1[i][j] + mat2[i][j];
       
        //Mostrar la Suma
        sayMatriz("\nMatriz 1",mat1);
        sayMatriz("\nMatriz 2",mat2);
        sayMatriz("\nMatriz Suma",suma);
    }
    public static void sayMatriz(String titulo, int mat[][]){
        System.out.println(titulo + "\n");
        for(int i = 0 ; i < mat.length ; i++){
            for(int j = 0 ; j < mat[i].length ; j++)
                System.out.print(mat[i][j] + "\t");
                System.out.println("");
           
        }
    }
}


Este programa nos permite encontrar la determinante de una matriz

package determinante;

/**
 *
 * @author Reynaldo
 */
public class Determinante {

   
    public static void main(String[] args) {
        double [][] matriz = {
                           {1,2,3},
                           {4,5,6},
                           {7,8,10}
             };
            
             for (int i=0;i<3;i++)
             {
                    for (int j=0;j<3;j++)
                           System.out.print(matriz[i][j]+" ");
                    System.out.println();
             }
            
             System.out.println("El determinante es "+Determinante.determinante(matriz));
       }

       public static double determinante (double [][] matriz)
       {
             assert matriz != null;
             assert matriz.length>0;
             assert matriz.length == matriz[0].length;
            
             double determinante = 0.0;
            
             int filas = matriz.length;
             int columnas = matriz[0].length;
            
             // Si la matriz es 1x1, el determinante es el elemento de la matriz
             if ((filas==1) && (columnas==1))
                    return matriz[0][0];
            

             int signo=1;
            
             for (int columna=0;columna<columnas;columna++)
             {
                    // Obtiene el adjunto de fila=0, columna=columna, pero sin el signo.
                    double[][] submatriz = getSubmatriz(matriz, filas, columnas,
                                  columna);
                    determinante = determinante + signo*matriz[0][columna]*determinante(submatriz);
                    signo*=-1;
             }
            
             return determinante;
       }

       public static double[][] getSubmatriz(double[][] matriz,
                    int filas,
                    int columnas,
                    int columna) {
             double [][] submatriz = new double[filas-1][columnas-1];
             int contador=0;
             for (int j=0;j<columnas;j++)
             {
                    if (j==columna) continue;
                    for (int i=1;i<filas;i++)
                           submatriz[i-1][contador]=matriz[i][j];
                    contador++;
             }
             return submatriz;
       }
}


La multiplicación de matrices requiere que el número de columnas de la matriz de la izquierda (A) sea igual al de la matriz de la derecha (B). Por ejemplo, para multiplicar una matriz A de cuatro columnas por fila por una matriz B (como en A x B), B debe contener exactamente cinco filas.

package matriz;

/**
 *
 * @author Reynaldo
 */

public class Matriz{

public static void main (String [] args) {
      int [][] a = {{ 10, 30 }, { 20, 40 }};
      int [][] b = {{ 5 }, { 7 }};

      volcado (a);
      System.out.println ();
      volcado (b);
      System.out.println ();
      int [][] c = multiplicacion (a, b);
      volcado (c);
   }

   static void volcado(int [][] x) {
      if (x == null) {
          System.err.println ("array es null");
          return;
      }
     
      for (int i = 0; i < x.length; i++) {
           for (int j = 0; j < x [0].length; j++)
                System.out.print(x [i][j] + " ");
                System.out.println ();
      }
   }

   static int [][] multiplicacion (int [][] a, int [][] b) {
     
      if (a [0].length != b.length) {
          System.err.println ("a's Número de columnas != b's recuento de filas");
          return null;
      }

      int [][] resultado = new int [a.length][];
      for (int i = 0; i < resultado.length; i++)
           resultado [i] = new int [b [0].length];
     
      // Realizar la multiplicación y la adición
      for (int i = 0; i < a.length; i++)
           for (int j = 0; j < b [0].length; j++)
                for(int k = 0; k < a [0].length; k++)
                    resultado [i][j] += a [i][k] * b [k][j];
     
      // Devuelve el resultado de la matriz
      return resultado;
   }
}

Ordenar una Matriz por el Metodo de la Burbuja



package metodoburbuja;

import java.util.Scanner;

/**
 *
 * @author Reynaldo
 */
public class Main {

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

        Scanner teclado = new Scanner(System.in);
        for(int i = 0 ; i < v.length ; i++){
            for(int j = 0 ; j < v.length ; j++){
               System.out.print("Ingrese un Numero: ");
               v[i][j] = teclado.nextInt();
        }
     }
        for(int  i=0; i < v.length; i++){//ordena la matriz de abajo hacia arriba
           for(int  j=0;j< v.length; j++){
              for(int x = 0; x < v.length; x++){
                  for(int y=0; y < v.length ; y++){
                     if(v[i][j] > v[x][y]){
                       int aux = v[i][j];
                       v[i][j] = v[x][y];
                       v[x][y] = aux;

                }
            }
        }
}
        }
        for (int i = v.length - 1 ; i >= 0 ; i--){//imprime la matriz ascendentemente
           for(int  j = v.length - 1 ; j >= 0 ; j--){

                System.out.print(" " + v[i][j]);
            }
        }
        System.out.println();
    }
}


0 comentarios:

Publicar un comentario

Deja tu Comentario.

 

©Copyright 2011 trinisoft | TNB