Listado completo de tutoriales

25 - Matrices irregulares


Java nos permite crear matrices irregulares. Se dice que una matriz es irregular si la cantidad de elementos de cada fila varía. Luego podemos imaginar una matriz irregular:

matriz irregular

Como podemos ver la fila cero tiene reservado dos espacios, la fila uno reserva cuatro espacios y la última fila reserva espacio para tres componentes.
Para crear la matriz irregular del gráfico:

La declaración es la misma que para matrices regulares:

int [][] mat;

Primero creamos la cantidad de filas dejando vacío el espacio que indica la cantidad de columnas:

mat=new int[3][];

Luego debemos ir creando cada fila de la matriz indicando la cantidad de elementos de la respectiva fila:

mat[0]=new int[2];
mat[1]=new int[4];
mat[2]=new int[3];

Luego la forma para acceder a sus componentes es similar a las matrices regulares, siempre teniendo en cuenta y validando que exista dicha componente:

mat[0][0]=120;

Dará un error si queremos cargar la tercer componente de la fila cero (esto debido a que no existe):

mat[0][2]=230;

Luego si queremos saber la cantidad de filas que tiene la matriz:

Sytem.out.println(mat.length);

Si queremos saber la cantidad de elementos de una determinada fila:

Sytem.out.println("Cantidad de elementos de la fila 0:"+mat[0].length);
Sytem.out.println("Cantidad de elementos de la fila 1:"+mat[1].length);
Sytem.out.println("Cantidad de elementos de la fila 2:"+mat[2].length);

Problema 1:

Confeccionaremos un programa que permita crear una matriz irregular y luego imprimir la matriz en forma completa.

Programa:

import java.util.Scanner;
public class MatrizIrregular1 {
    private Scanner teclado;
    private int[][] mat;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        mat=new int[filas][];
        for(int f=0;f<mat.length;f++) {
            System.out.print("Cuantas elementos tiene la fila " + f + ":");
            int elementos=teclado.nextInt();
            mat[f]=new int[elementos];            
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void imprimir() {
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] ar) {
        MatrizIrregular1 ma=new MatrizIrregular1();
        ma.cargar();
        ma.imprimir();
    }   
}

Primero creamos la cantidad de filas que tendrá la matriz (en los corchetes para las columnas no disponemos valor):

        System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        mat=new int[filas][];

Dentro del primer for pedimos que ingrese la cantidad de elementos que tendrá cada fila y utilizamos el operador new nuevamente, pero en este caso se están creando cada fila de la matriz (Java trata a cada fila como un vector):

        for(int f=0;f<mat.length;f++) {
            System.out.print("Cuantas elementos tiene la fila " + f + ":");
            int elementos=teclado.nextInt();
            mat[f]=new int[elementos];            

Dentro del for interno hacemos la carga de las componentes propiamente dicho de la matriz (podemos ir cargando cada fila a medida que las vamos creando):

            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }

Luego imprimimos la matriz en forma completa teniendo cuidado las condiciones que disponemos en cada for.
El primer for se repite tantas veces como filas tiene la matriz: f<mat.length y
el for interno se repite tantas veces como elementos tiene la fila que estamos procesando c<mat [f].length:

        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }

Problemas propuestos

  1. Confeccionar una clase para administrar una matriz irregular de 5 filas y 1 columna la primer fila, 2 columnas la segunda fila y así sucesivamente hasta 5 columnas la última fila (crearla sin la intervención del operador)
    Realizar la carga por teclado e imprimir posteriormente.
  2. Confeccionar una clase para administrar los días que han faltado los 3 empleados de una empresa.
    Definir un vector de 3 elementos de tipo String para cargar los nombres y una matriz irregular para cargar los días que han faltado cada empleado (cargar el número de día que faltó)
    Cada fila de la matriz representan los días de cada empleado.
    Mostrar los empleados con la cantidad de inasistencias.
    Cuál empleado faltó menos días.
Solución
import java.util.Scanner;
public class MatrizIrregular2 {
    private Scanner teclado;
    private int[][] mat;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        mat=new int[5][];
        for(int f=0;f<mat.length;f++) {
            mat[f]=new int[f+1];            
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void imprimir() {
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] ar) {
        MatrizIrregular2 ma=new MatrizIrregular2();
        ma.cargar();
        ma.imprimir();
    }  
}




import java.util.Scanner;
public class MatrizIrregular3 {
    private Scanner teclado;
    private String[] nombres;
    private int[][] dias;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        nombres=new String[3];
        dias=new int[3][];
        for(int f=0;f<nombres.length;f++) {
            System.out.print("Ingrese el nombre del empleado:");
            nombres[f]=teclado.next();
            System.out.print("Cuantas días faltó el empleado:");
            int faltas=teclado.nextInt();
            dias[f]=new int[faltas];            
            for(int c=0;c<dias[f].length;c++) {
                System.out.print("Ingrese nro de día:");
                dias[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void inasistencias() {
        for(int f=0;f<nombres.length;f++) {
            System.out.println(nombres[f] + " faltó " + dias[f].length + " días");
        }
    }
    
    public void empleadoMensosFaltas() {
        int faltas=dias[0].length;
        String nom=nombres[0];
        for(int f=1;f<dias.length;f++) {
            if (dias[f].length<faltas) {
                faltas=dias[f].length;
                nom=nombres[f];
            }
        }
        System.out.println("El empleado que faltó menos es "+nom+" con "+faltas+" faltas.");
    }
    
    public static void main(String[] ar) {
        MatrizIrregular3 ma=new MatrizIrregular3();
        ma.cargar();
        ma.inasistencias();
        ma.empleadoMensosFaltas();
    }   
}

Retornar