Arreglos bidimensionales Java parte 4

2
INDICE
N° DE PAG.
Programa que lee un arreglo bidimensional para después imprimirlo 3
Programa que lee un arreglo bidimensional para después imprimirlo separando el método leer del
método imprimir 5
Programa que lee por columnas un arreglo bidimensional para después imprimirlo 7
Programa que lee un arreglo bidimensional e imprime los valores de la
diagonal principal 9
Programa que lee una matriz e imprime su diagonal principal ordenada 11
Programa que lee una matriz y la convierte en un vector de acuerdo al orden
de filas y un vector de acuerdo al orden de columnas 14
Programa que lee una matriz e imprime su perímetro 17
Programa que lee una matriz y ordena las filas en de menor a mayor
y las columnas de mayor a menor 20
Programa que lee una matriz A, una Matriz B, multiplica la Matriz A por la matriz B y guarda
los resultados en una matriz C para después imprimir las tres Matrices 23
Programa que lee una matriz bidimensional e imprime su transpuesta ...27
Programa que lee una matriz bidimensional y cambia las diagonales
principales 29
Programa que lee una matriz bidimensional e imprime la matriz
simetrica basandose en los valores de arriba de la diagonal .32

3
/**@ ITO Fundamentosde programación
* @ Este programa lee unarreglobidimensional paradespués imprimirlo
* @author JoaquínMartínez Benjamín
*/
importjavax.swing.*;
publicclassLeerXfila{
publicLeerXfila(){}
intn[][];
intrenglon,columna;
StringmatrizImpresa="";
publicvoidleerHacer(){
renglon=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de renglones"));
columna=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de columnas"));
n= new int[renglon] [columna];
for (intx=0; x<renglon;x++) {
for (inty=0; y <columna;y++) {
n[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Introduzcael elemento
["+x+"]["+y+"] del arreglo"));
matrizImpresa+=n[x][y] +" ";
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"Elarregloes: n"+matrizImpresa);
}
publicstaticvoidmain( Stringargs []){
LeerXfilaresult=new LeerXfila();
result.leerHacer();
}
}

5
* @ Este programa lee unarreglobidimensional para después imprimirlo
* separandoel métodoleerdel métodoimprimir
*/
publicclassLeerXfila2{
publicLeerXfila2(){}
intrenglon=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de renglones"));
intcolumna=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de columnas"));
intn[][]=new int[renglon] [columna];
publicvoidleer(){
n[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Introduzcael elemento["+x+"]["+y+"]
del arreglo"));
}
}
}
publicvoidhacer(){
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"El arregloes: n"+matrizImpresa);
}
LeerXfila2result=new LeerXfila2();
result.leer();
result.hacer();
}
}

7
/**@ ITO Fundamentos de programación
* @ Este programa lee porcolumnasunarreglobidimensional paradespuésimprimirlo
*/
publicclassLeerXcolumna{
publicLeerXcolumna(){}
intn[][];
inttranspuesta[][];
intrenglon,columna;
columna=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de renglones"));
renglon=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de columnas"));
transpuesta=new int[columna][renglon];
n[x][y]=Integer.parseInt(JOptionPane.showInputDialog ("Introduzcael elemento
["+y+"]["+x+"] del arreglo"));
}
}
for (intx=0; x<columna;x++) {
for (inty=0; y <renglon;y++) {
transpuesta[x][y]=n[y][x];
matrizImpresa+=transpuesta[x][y] +" ";
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizes:n"+matrizImpresa);
}
LeerXcolumnaresult=new LeerXcolumna();
result.leerHacer();
}
}

9
* @ Este programa lee unarreglobidimensional e imprime losvaloresde la
* diagonal principal
*/
publicclassImprimirDiagonal{
publicImprimirDiagonal(){}
intn = Integer.parseInt(JOptionPane.showInputDialog("Inserte el númerode columnas"));
intconta=0;
Stringdiagonal="";
int[][]matriz=new int[n][n];
publicvoidcrearMatriz() {
for(intx=0;x<n; x++)
for(inty=0;y<n; y++)
{
matriz[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Ingrese valoresenlamatriz"));
}
for(intx=0;x<n; x++) {
{
matrizImpresa+=matriz[x][y]+"";
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizes: n"+matrizImpresa+"n");
}
publicvoidbuscarDiagonal(){
while (conta< n)
{
diagonal+=matriz[conta][conta]+"";
diagonal+="n";
conta ++;}
JOptionPane.showMessageDialog(null,"Ladiagonal es: n"+diagonal);
}

10
publicstaticvoidmain(Stringargs[]){
ImprimirDiagonal arreglo=newImprimirDiagonal();
arreglo.crearMatriz();
arreglo.buscarDiagonal();
}
}

11
* @(#)OrdenarDiagonal.java
* @ Este programa lee unamatrize imprime sudiagonal principal ordenada
*/
publicclass OrdenarDiagonal{
publicOrdenarDiagonal(){}
intn = Integer.parseInt(JOptionPane.showInputDialog("Inserte el númerode filasycolumnas"));
intdiagonal=0;
publicvoidcrearMatriz1() {
StringmatrizImpresa2="";
int[][] matriz1;
matriz1= new int[n][n];
{
matriz1 [x] [y]=Integer.parseInt(JOptionPane.showInputDialog("Ingrese valoresenlamatriz"));
}
for(intx=0;x<n; x++){
for(inty=0;y<n; y++){
matrizImpresa+=matriz1[x] [y]+" ";
}
matrizImpresa+="n";
}
for(intconta=0; conta< n-1; conta++)
for(intconta2=conta+1; conta2 < n; conta2++){
if ( matriz1[conta][conta]>matriz1[conta2][conta2]){
diagonal=matriz1[conta] [conta];
matriz1[conta][conta]=matriz1[conta2][conta2];
matriz1[conta2][conta2]=diagonal;
}
}

12
matrizImpresa2+=matriz1[x][y]+" ";
}
matrizImpresa2+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizes: n"+matrizImpresa+"nConladiagonal
ordenada"
+ "la matrizesn"+matrizImpresa2);
}
OrdenarDiagonal arreglo=new OrdenarDiagonal();
arreglo.crearMatriz1();
}
}

14
* @ Este programa lee unamatrizy laconvierte enunvectorde acuerdoal orden
* de filasy un vectorde acuerdo al ordende columnas
*/
publicclassFilasColumnas{
publicFilasColumnas(){}
intm = Integer.parseInt(JOptionPane.showInputDialog("Inserte el númerode filas"));
intn = Integer.parseInt(JOptionPane.showInputDialog("Inserte el númerode columnas"));
int[][] matriz1;
matriz1= new int[m][n];
intvector[]=new int[m*n];
intvector2[]=new int[m*n];
StringvectorImpreso="";
StringvectorImpreso2="";
intconta=0;
for(intx=0;x<m; x++)
{
matriz1 [x][y]=Integer.parseInt(JOptionPane.showInputDialog("Ingresevaloresenlamatriz"));
}
for(intx=0;x<m; x++){
matrizImpresa+=matriz1[x][y]+"";
vector[conta]=matriz1[x][y];
conta ++;
}
matrizImpresa+="n";
}

15
conta=0;
for(inty=0;y<m; y++){
vector2[conta]=matriz1[y][x];
conta ++;
}
matrizImpresa+="n";
}
for(intx=0;x<m*n; x++) {
vectorImpreso+=vector[x]+"n";
vectorImpreso2+=vector2[x]+"";
}
JOptionPane.showMessageDialog(null,"Lamatrizes: n"+matrizImpresa
+"El vectorpor filases: n"+vectorImpreso+"nEl vectorporcolumnasesn"+vectorImpreso2);
}
FilasColumnasarreglo=new FilasColumnas();
}
}

17
* @ Este programa lee unamatrize imprime su perímetro
*/
publicclassPerimetro{
publicPerimetro(){}
intn[][];
intrenglon;
intcontadorFila=0;
intcontadorY=0;
intcontadorX=0;
Stringperimetro="";
renglon=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de renglonesycolumnas"));
n= new int[renglon] [renglon];
////////////////////////////Rellenae imprimelamatriz/////////////////
for (inty=0; y<renglon;y++) {
n[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Ingrese valoresenlamatriz"));
}
matrizImpresa+="n";
}
///////////////////////////Obtieneel perímetro////////////////////////////
while (contadorFila<renglon){
if (contadorFila==0){
while (contadorY<renglon){
contadorX=0;
perimetro+=n[contadorX][contadorY]+" ";
contadorY++;
}
perimetro+="n";
}

18
if (contadorFila==renglon-1){
while (contadorY<renglon){
contadorX= renglon-1;
perimetro+= n[contadorX][contadorY]+" ";
contadorY++;
}
perimetro+= "n";
}
if (!(contadorFila==0||contadorFila==renglon-1)){
contadorX=contadorFila;
inti=0;
while (i<renglon -2){
perimetro+=" ";
i++;
}
contadorY=contadorY+ (renglon-1);
perimetro+="n";
}
contadorX=0;
contadorY=0;
contadorFila++;
}
JOptionPane.showMessageDialog(null,"Lamatrizes: n"+matrizImpresa
+"nEl perímetroes: n"+perimetro);
}
Perimetroresult=newPerimetro();
result.leerHacer();
}
}

20
* @ Este programa lee unamatrizy ordenalasfilas ende menora mayor
* y lascolumnasde mayora menor
*/
publicclassOrdenarFilasColumnas{
publicOrdenarFilasColumnas(){}
intmatrizFilas[][];
intmatrizColumnas[][];
intrenglon,columna;
intaux;
Stringmatriz="";
Stringmatriz2="";
Stringmatriz3="";
renglon=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de renglones"));
columna=Integer.parseInt(JOptionPane.showInputDialog("Escribael total de columnas"));
matrizFilas = new int [renglon] [columna];
matrizColumnas=new int[renglon] [columna];
////////// Rellenalamatrizyla guarda para imprimir////////////////////
for (inty=0; y <columna; y++) {
matrizFilas[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Introduzcael elemento
del arreglo"));
matrizColumnas[x][y]=matrizFilas[x][y];
matriz+= matrizFilas[x][y] +" ";
}
matriz+="n";
}
//////////////Ordenalasfilasenordendescendente///////////////////////
for (inty=0; y <columna-1;y++) {
if(matrizFilas[x][y]>matrizFilas[x][y+1]) {
aux=matrizFilas[x][y];
matrizFilas[x][y]=matrizFilas[x][y+1];
matrizFilas[x][y+1]=aux; }
}
}

21
////////////////////Ordenalascolumnasenorden
ascendente///////////////////////////////////////
for(intx=0;x<columna;x++){
for(inty=0;y<renglon-1;y++){
if(matrizColumnas[y][x]<matrizColumnas[y+1][x]) {
aux=matrizColumnas[y][x];
matrizColumnas[y][x]=matrizColumnas[y+1][x];
matrizColumnas[y+1][x]=aux;}
}
}
////////////////////Guardalamatrizde filasy de columnasordenadasparaimprimir///////////
matriz2+= matrizFilas[x][y] +" ";
matriz3+= matrizColumnas[x][y]+"";
}
matriz2+="n";
matriz3+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizes:n"+matriz+"nLamatrizconfilasordenadas
esn"
+matriz2+"nLa matrizcon lascolumnasordenadasesn"+matriz3);
}
OrdenarFilasColumnasresult=new OrdenarFilasColumnas();
result.leerHacer();
}
}

23
//Programaque lee unamatrizA, unaMatriz B, multiplicalaMatrizA por la matrizB y guarda
// losresultadosenunamatrizC para despuésimprimirlas tresMatrices.
publicclassMatrizMultiplicacion{
publicMatrizMultiplicacion(){}
inttotfilasA;
inttotcolumnasA;
inttotfilasB;
inttotcolumnasB;
intmatrizA[][];
intmatrizB[][];
intmatrizC[][];
StringA="";
StringB="";
StringC="";
publicvoidcrearDatos(){
totfilasA= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el númerode filasde lamatrizA"));
totcolumnasA=Integer.parseInt(JOptionPane.showInputDialog("Ingreseel númerode columnasde lamatriz
A"));
totfilasB=Integer.parseInt(JOptionPane.showInputDialog("Ingreseel número de filasde lamatrizB"));
do{
if (totcolumnasA!=totfilasB){
totfilasB=Integer.parseInt(JOptionPane.showInputDialog("El númerode filasde lamatrizB debe serigual "+
"al númerode columnasde lamatrizAnIngrese nuevamente el númerode filasde lamatrizB"));
}
}while (totcolumnasA!=totfilasB);
totcolumnasB=Integer.parseInt(JOptionPane.showInputDialog("Ingreseel númerode columnasde lamatriz
B"));
matrizA=new int[totfilasA][totcolumnasA];
matrizB= new int[totfilasB][totcolumnasB];
matrizC=new int [totfilasA][totcolumnasB];
}
/////////////////////////////ABREMETODOLEER MATRICES//////////////////////////
publicvoidleerMatrices(){
for ( int filasA =0; filasA <totfilasA; filasA++){
for ( int columnasA =0; columnasA < totcolumnasA;columnasA++){
matrizA[filasA][columnasA]=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento["
+filasA+"]["+columnasA+"] de lamatrizA"));
}
}

24
/////////////////////////////////////////////////////////////////////////////////
for ( int filasB= 0; filasB< totfilasB; filasB++){
for ( int columnasB= 0; columnasB< totcolumnasB;columnasB++){
matrizB[filasB][columnasB]=Integer.parseInt(JOptionPane.showInputDialog("Ingreseel elemento["
+filasB+"]["+columnasB+"] de lamatrizB"));
}
}
}
////////////////////////////ABREMETODO MULTIPLICAR////////////////////////////
publicvoidMultiplicar(){
for ( int j = 0; j < totfilasA;j++){ // controla el ordenenque se debe trabajarcon las filas
for ( int k = 0; k < totcolumnasB;k++){// lascolumnasse usanmás y se reiniciandespuésde que se terminacon
una filade A
//por esova dentrodel for de filasde A
for( inti = 0; i < totfilasB;i++){//tambiénse podriausarel total de columnasde A como
condición
// para entrar al forpueslosvaloresde columnasde Ay filasde B
// son iguales
matrizC[j][k] +=matrizA[j][i]*matrizB[i][k];
//un elementode unafilade A se multiplicanconunelementode unacolumnasde B
//cuando todosloselementosde unafilade Ase han multiplicadocontodosloselementos
de una columnade B
//segúnel ordenque controlai, losresultadosse vansumandoy guardandoenun elemento
de una filade la matrizC
//es por esoque j aumentamaslentoque K, ya que K llevalacuentade las columnasque se
debencrear
//en C.
}
}
}
}
/////////////////////////////ABREMETODOIMPRIMIR MATRICES//////////////////////////
publicvoidimprimirMatrices(){
for ( int filasA =0; filasA <totfilasA; filasA++){
for ( int columnasA =0; columnasA < totcolumnasA;columnasA++){
A+=matrizA[filasA][columnasA]+"";
} A+= "n";
}

25
/////////////////////////////////////////////////////////////////////////////////
for ( int filasB= 0; filasB< totfilasB; filasB++){
for ( int columnasB= 0; columnasB< totcolumnasB;columnasB++){
B+=matrizB[filasB][columnasB]+"";
}B+= "n";
}
//////////////////////////////////////////////////////////////////////////////////
for ( int filasC=0; filasC< totfilasA; filasC++){
for ( int columnasC= 0; columnasC< totcolumnasB;columnasC++){
C+=matrizC[filasC][columnasC]+"";
}C+= "n";
}
//////////////////////////////////////////////////////////////////////////////////
JOptionPane.showMessageDialog(null,"LamatrizAes: n"+A+"nLa matrizB es:n"+B+"El productode AX B
es:n"+C);
}
///////////////////////////////////////////////////////////////////////////////
publicstaticvoidmain(String[]args){
MatrizMultiplicacionMulti=new MatrizMultiplicacion();
Multi.crearDatos();
Multi.leerMatrices();
Multi.Multiplicar();
Multi.imprimirMatrices(); }
}//cierraclase

27
* @ Este programa lee unamatrizbidimensional e imprimesutranspuesta
*/
publicclassTrans{
publicTrans(){}
intoriginal[][];
inttranspuesta[][];
intrenglon,columna;
StringoriginalImpresa="";
StringtranspuestaImpresa="";
original=new int[renglon][columna];
transpuesta=new int[columna][renglon];
original[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Introduzcael
elementodelarreglo"));
originalImpresa+="["+original[x][y]+"] ";
}
originalImpresa+="n";
}
for (intx=0; x<columna;x++) {
for (inty=0; y <renglon;y++) {
transpuesta[x][y]=original[y][x];
transpuestaImpresa+=transpuesta[x][y]+" ";
}
transpuestaImpresa+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizoriginal es:n"+originalImpresa+"nLamatriz
transpuestaes:n"+transpuestaImpresa);
}

28
Trans result=new Trans ();
result.leerHacer();
}
}

29
* @ Este programa lee unamatrizbidimensional ycambialasdiagonales
* principales
*/
publicclassDiagonalInversa{
publicDiagonalInversa(){}
intn = Integer.parseInt(JOptionPane.showInputDialog("Inserte el númerode filasycolumnas"));
intaux= 0;
StringmatrizImpresa2="";
int[][] matriz1;
matriz1= new int[n][n];
///////////////////LEELA MATRIZ///////////////////////////
{
matriz1 [x][y]=Integer.parseInt(JOptionPane.showInputDialog("Ingresevaloresenla
matriz"));
}
matrizImpresa+=matriz1[x] [y]+" ";
}
matrizImpresa+="n";
}
///////////////////INVIERTELASDIAGONALESY GUARDA LA NUEVA MATRIZ////////////////
int y= n-1;
for(intx=0; x< n; x++){
aux= matriz1[x][x];
matriz1[x][x]=matriz1[x][y];
matriz1[x][y]=aux;
y--;
}

30
for(intx=0; x<n;x++){
for( y=0; y<n; y++){
matrizImpresa2+=matriz1[x][y]+" ";
}
matrizImpresa2+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizes:n"+matrizImpresa+"nConladiagonal
inversa"
+ "la matrizes:n"+matrizImpresa2);
}
DiagonalInversaarreglo=new DiagonalInversa();
}
}

32
* @ Este programa lee unamatrizbidimensional e imprimelamatriz
* simetricabasandose enlosvaloresde arribade ladiagonal
*/
publicclassTriangularSuperior{
publicTriangularSuperior(){}
intn[][];
intsimetrica[][];
intrenglon,columna;
intaux;
Stringoriginal="";
StringsimetricaImpresa="";
simetrica=new int[columna][renglon];
n[x][y]=Integer.parseInt(JOptionPane.showInputDialog("Introduzcael elemento["+x+"]["+y+"]
del arreglo"));
original+=n[x][y]+" ";
}
original+="n";
}
for (inty=x;y <columna;y++) {
simetrica[y][x]=n[x][y];
}
}

33
inty=0;
for ( y=x;y <columna;y++) {
simetrica[x][y]=n[x][y];
}
}
for ( y=0; y <columna;y++) {
simetricaImpresa+=simetrica[x][y]+" ";
}
simetricaImpresa+="n";
}
JOptionPane.showMessageDialog(null,"Lamatrizoriginal es: n"+original+"nLamatrizsimetrica
esn"
+simetricaImpresa);
}
TriangularSuperiorresult=new TriangularSuperior();
result.leerHacer();
}
}

Arreglos bidimensionales Java parte 4

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Arreglos bidimensionales Java parte 4

Similar a Arreglos bidimensionales Java parte 4 (20)

Más de Benjamín Joaquín Martínez

Más de Benjamín Joaquín Martínez (20)

Último

Último (8)

Arreglos bidimensionales Java parte 4