ARREGLOS BIDIMENSIONALES

• Conceptos Básicos:

{ clrscr();
printf("\n\n");
for(i=1;i<=n;i++)Los arreglos bidimensionales son tablas de valores. Cada uno de sus elementos tiene una posición que se identifica mediante dos índices: el de su fila y el de su columna.

Ejemplo:

P= [4] [3]; que se interpreta como el elemento en la cuarta fila y tercera columna.

Son estructuras de datos que agrupan muchos datos del mismo tipo, en donde cada elemento se puede trabajar individualmente y se puede referenciar con un mismo nombre.

Un arreglo bidimensional está compuesto, por un conjunto de elementos homogéneos y se puede acceder a los datos utilizando dos subíndices, este tipo de arreglo es también conocido como matriz.

El uso de arrays con más de 2 dimensiones no es muy común.

matriz[0][0]	matriz[0][1]	matriz[0][2]
matriz[1][0]	matriz[1][1]	matriz[1][2]
matriz[2][0]	matriz[2][1]	matriz[2][2]

Estructura de un arreglo bidimensional de 3x3

• Operaciones

Para manejar un arreglo, las operaciones a efectuarse son:

 DECLARACIÓN:

 La declaración de un arreglo consiste en establecer las características del arreglo y sus elementos por medio de la siguiente sintaxis:

<tipo_de_dato> <identificador_del_arreglo> [Dimensión_fila] [Dimensión_columna]

Donde:

Tipo de dato indica el tipo correspondiente a los elementos del arreglo.

Identificador del arreglo es el nombre del arreglo.

El par de corchetes ([  ]) representan las dimensiones del arreglo y encierra dos números enteros, cuyo producto corresponde al número de elementos del arreglo.

Por ejemplo:

1) int arreglo[10][10];

2) float matriz[10][10];

También podemos utilizar constantes para definir la dimensión del arreglo de dos dimensiones:

3) const int N = 10;

4) int arreglo[N][N];

5) int a [4] [3];

a[0][0]	a[0][1]	a[0][2]
a[1][0]	a[1][1]	a[1][2]
a[2][0]	a[2][1]	a[2][2]
a[3][0]	a[3][1]	a[3][2]

      CREACIÓN:

Consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:

< identificador > = new <tipo> [ dim1, dim2 ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

dim1 y dim2 son valores enteros que representan las dimensiones del arreglo.

El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.

Por ejemplo:

matriz = new double [2, 3] ; 

// Se crea el arreglo matriz, con 6 elementos de tipo

// Punto flotante y precisión doble.

  INICIALIZACIÓN:

Una matriz o arreglo bidimensional se puede inicializar de este modo:

int matriz[3][3] = {{1,2,3},{4,5,6},{7,8,9}};

Con la anterior asignación se crea en memoria una matriz igual a la de abajo:

	0	1	2
0	1	2	3
1	4	5	6
2	7	8	9

Fig. 8.1

A las matrices se le asignan automáticamente valores iniciales
predeterminados a cada uno de sus elementos, de acuerdo a los
siguientes criterios:

Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.

Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.

Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.

Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.

Por ejemplo:

Leer, desde el teclado, una matriz de números enteros de dimensión 3x3.

#include <iostream.h>

void main()

{

const int TAM=3;

int matriz[TAM][TAM];

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

{

for( int j=0; j<TAM; j++)

{

cout<<”Ingrese el elemento [“<<i<<”,“<<j<<”] “;

cin>>matriz[I][j];

}

}

 ACCESO A LOS ELEMENTOS DE UN ARREGLO BIDIMENSIONAL:

En un arreglo de dos dimensiones necesitamos también dos índices para acceder a sus elementos.

Si utilizamos: matriz[i] [j], entonces i se refiere a la fila y j a la columna.

Para acceder al elemento de la segunda fila y segunda columna de la matriz de la Fig. 8.1 hacemos:

int nro = matriz[1][1];

En la variable nro se guardara el número 5.

Las matrices o arreglos bidimensionales se suelen utilizar en cálculos matemáticos, operaciones con matrices, recorridos por matrices, y cualquier uso que nosotros le podamos dar.

Se pueden definir arreglos de más de 2 dimensiones, pero su manejo se dificultaría enormemente.

-Inserción Directa de Elementos en un Arreglo Bidimensional:

<Nombre del arreglo> [índice de fila] [índice de columna]= valor
del elemento;

<Nombre del arreglo> [<m>] [<n>]= valor del elemento

Por ejemplo:

M [3] [2]=9        M [3,2]=9

- Extracción Directa de Elementos en un Arreglo Bidimensional:

<Identificador variable>=<nombre del arreglo> [índice de fila][índice de columna]

Por ejemplo:

x =M [3] [2]            x= M [3,2]

Aplicaciones

¿Cómo realizar un programa con arreglos bidimensionales?

Para el desarrollo de esta práctica, se lleva a cabo el siguiente algoritmo:

1.- Se da el número de renglones (n) y columnas (m).

2.- n*m, es la dimensión de la matriz

3.- Repetir con i desde 1 hasta

Repetir con j desde 1 hasta m

Leer matriz [i, j]

Continúa con j

Continúa con i

4.- Para insertar: es necesario verificar si hay espacio; si no, primero eliminar. Si hay espacio, se pide el elemento a insertar, se busca la nueva posición y se inserta el nuevo elemento.

5.- Para eliminar: se pide el elemento a eliminar, si se encuentra, se elimina.

6.- Para modificar: se busca el elemento a modificar, se da el elemento por el que se va a reemplazar, si se encuentra se reemplaza, si no se despliega un mensaje notificando al usuario.

Por lo tanto el código fuente quedaría:

En el caso de INSERCIÓN de un elemento

{
for(j=1;j<=m;j++)
{
printf("\b\bELEMENTO[%d][%d]=%d\n ",i,j,mat[i][j]);
}
}
gotoxy(5,8);
cprintf("ELEMENTO A INSERTAR:");scanf("%d",&ei);
if (nae<nte)
{
nae++;
b=0;
while(b!=1)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if(b==1)
break;
if(mat[i][j]=='\0')
{
b=1;
mat[i][j]=ei;
break;
}  

}
} 

}
printf("\n\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf("\b\bELEMENTO[%d][%d]=%d\n ",i,j,mat[i][j]);
}
}
}
else
{
gotoxy(3,9);
cprintf(" LA MATRIZ ESTA LLENA ");
}
getch();
} break;

En el caso de ELIMINACIÓN de un elemento:

{ clrscr();
printf("\n\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf("\b\bELEMENTO[%d][%d]=%d\n ",i,j,mat[i][j]);
}
}
gotoxy(5,8);
cprintf("ELEMENTO A ELIMINAR: ");scanf("%d",&e);
if (nae>1)
{
ban=0;
i=1;
j=1;
while(ban!=1)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if(mat[i][j]==e)
{
ban=1;
nae--;
mat[i][j]='\0';
}
}
}
}
if (ban==0)
{
gotoxy(3,9);
cprintf("ELEMENTO %d NO EXISTE EN LA MATRIZ",e,mat[i][j]);
}
}
else
{
gotoxy(3,9);
cprintf("LA MATRIZ ESTA VACIA\n\n");
}
mat[n][m]=4;
printf("\n\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf("\b\bELEMENTO[%d][%d]=%d\n ",i,j,mat[i][j]);
}
}
getch();

}break;

Y para la MODIFICACIÓN de un elemento el código fuente fue:

{ clrscr();
printf("\n\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf("\b\bELEMENTO[%d][%d]=%d\n ",i,j,mat[i][j])
}
}
gotoxy(5,8);
cprintf("ELEMENTO A MODIFICAR: ");scanf("%d",&mi);
gotoxy(5,9);
cprintf("NUEVO ELEMENTO: ");scanf("%d",&ni);
if(nae>1)
{
i=1,
j=1;
b=0;
while(b!=1)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if (b==1)
break;

if (mat[i][j]==mi)
{
b=1;
mat[i][j]=ni;
break;
}
}
}
}
if (b==0)
{
gotoxy(3,10);
cprintf("ELEMENTO %d NO EXISTE EN LA MATRIZ",mi);
}
}
if (nae==0)
cprintf("LA MATRIZ ESTA VACIA");
printf("\n\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf("\b\bELEMENTO[%d][%d]=%d\n ",i,j,mat[i][j]);
}
}
getch();

} break;