Aprendiendo C/C++ Paso a Paso - Página 7

07. Paso a Paso C/C++ — Programación en C - Arreglos

| | 5. Tipos de Arreglos | | - Arreglos Unidimensionales 1. Agregar elemento

2. Insertar elemento
3. Eliminar elemento
4. Reemplazar elemento
5. Buscar elemento
6. Eliminación de arreglo
7. Ordenación de un arreglo - Arreglos Multidimensionales
   Operaciones de Matriz usando Arreglos Multidimensionales | |

1. Introducción a los arreglos

Una variable puede contener un valor constante. Solo un único valor constante y no es posible contener más de un valor en una variable.

El siguiente ejemplo demuestra el alcance de una variable.

| | int main()
{
int sno;
sno = 1001;
sno = 1008;
sno = 1005;
printf(“%d”, sno);
return 0;
} | | | Salida:
1005 |

El programa anterior es capaz de mostrar solo 1005, pero no todos los valores (es decir, 1001, 1008, 1005 ).

¿Podemos sustituir el siguiente programa en lugar del programa anterior?

| | int main()
{
int sno;
sno 0 = 1001;
sno 1 = 1008;
sno 2 = 1005;
printf(“%d”, sno);
return 0;
} | | | Salida:
Nada,
El programa anterior muestra una lista de errores, porque el enfoque es incorrecto. |

Continuemos con el siguiente programa para obtener un programa sin errores.

| | int main()
{
int sno[3];
sno[0] = 1001;
sno[1] = 1008;
sno[2] = 1005;
printf(“%d”, sno[2] );
return 0;
} | / 3 valores a insertar /
/ Primera ubicación para insertar 1001 /
/ Siguiente ubicación para insertar 1008 /
/ y Siguiente ubicación para insertar 1005 /
/ Imprime el valor de la 2ª ubicación / | | | | | Salida:
Nada | |

El programa anterior muestra una lista de errores, porque el enfoque es incorrecto.

Dependiendo del programa anterior, la variable sno puede contener más de un número de estudiante. Es fácil, utilizando la técnica de múltiples ubicaciones, también conocida como arreglos.

2. Acerca de los Arreglos

Los arreglos contienen una cantidad de elementos de datos del mismo tipo. Este tipo puede ser un tipo de dato simple, una estructura o una clase. Los elementos en un arreglo se llaman elementos. El número accede a los elementos; este número se llama índice. Los elementos pueden ser inicializados a valores específicos cuando se define el arreglo.

Los arreglos pueden tener múltiples dimensiones.

Un arreglo bidimensional es un arreglo de arreglos. La dirección de un arreglo puede ser utilizada como un argumento para una función; el arreglo en sí no se copia. Los arreglos pueden ser utilizados como datos de miembro en clases. Se debe tener cuidado para evitar que los datos se coloquen en la memoria fuera de un arreglo.

/ El siguiente programa lee la edad de 4 personas y la muestra /

| | / 47_arrays.c /
#include
int main()
{
int age[4], i;
for( i=0; i<4; i++)
{
printf(“Ingrese una edad “); scanf(“%d”, &age[i]);
}

for(i=0; i<4; i++)
printf(“\nUsted ingresó %d”, age[i]);

return 0;
} |

| | |

Como otras variables en C, un arreglo debe ser definido antes de que pueda ser utilizado para almacenar información. Y, como otras definiciones, una definición de arreglo especifica un tipo de variable y un nombre.

Pero incluye otra característica: un tamaño. El tamaño especifica cuántos elementos de datos contendrá el arreglo. Sigue inmediatamente al nombre y está rodeado por corchetes.

3. Elementos del Arreglo

Los elementos en un arreglo se llaman elementos. Un arreglo unidimensional acepta valores de manera fila o columna. Solo puede almacenar un conjunto de valores.
El primer elemento del arreglo es 0, el segundo es 1 y así sucesivamente.

| | |

Un valor de arreglo puede ser inicializado directamente en el tiempo de diseño.
La inicialización de arreglos es la siguiente..

| | |

4. Pasando Arreglos a Funciones

Los arreglos pueden ser utilizados como argumentos para funciones.

En una declaración de función, el tipo de dato y los tamaños del arreglo representan argumentos de arreglo.

void display(float [DISPLAY][MONTHS]);

Cuando se llama a la función, solo se utiliza el nombre del arreglo como argumento.

 display(sales); 

Programa para aceptar e imprimir un arreglo de 10 elementos

| | / 48_ ele10.c /
#define MAX 10
display(int a[MAX])
{
int i;
for(i = 0;iprintf(“\n%d”,,a[i]);
}

int main()
{
int x[MAX], i;
for(i=0;iscanf(“%d”,&x[i]);

display(x);

return 0;
} |

Devolver un arreglo de valores desde funciones también es posible, pero debemos estar claros con el concepto de punteros. Por favor, consulte los temas de punteros para más información.

5. Clasificación de Arreglos

Los arreglos son de dos tipos.

| | 1. Arreglos Unidimensionales

2. Arreglos Multidimensionales |

1. Arreglos Unidimensionales

Un arreglo unidimensional es una colección de elementos en una fila o en una columna.
Un arreglo unidimensional puede aceptar las siguientes operaciones.

| | 1. Agregar elemento

2. Insertar elemento
3. Eliminar elemento
4. Reemplazar elemento
5. Buscar elemento
6. Eliminación de arreglo
7. Ordenación de un arreglo |

El siguiente programa es capaz de realizar todas las tareas descritas anteriormente.

| | / FUNCIONES DE ARREGLO /
/ 49_sarray.c /
#define N 100
#define M 10
int i,j,r,c,r1,r2,c1,c2; / Leer elementos del arreglo /
int accept_values(int a[N])
{
int n;
printf(“\n¿Cuántos valores desea ingresar..? “);
scanf(“%d”,&n);
printf(“\nIngrese los elementos de datos.. ”);
for(i=0;iscanf(“%d”,&a[i]);
return n;
} / Mostrar elementos del arreglo /
void display(int a[N],int n)
{
printf(“\n Los elementos del arreglo son…”);
for(i=0;iprintf(“\n%d”,a[i]);
} / Eliminar elemento del arreglo /
int delete_cell(int a[N],int n)
{
int pos;
char ch;
printf(“\nIngrese la posición del elemento a eliminar: “);
scanf(“%d”,&pos);
for(i=pos-1;ia[i] = a[i+1];
n–;
printf(“\n ¿Desea continuar..(y/n)?”);
ch = getche();
if(ch == ‘y’) delete_cell(a,n);
return n;
} / Insertar elemento en el arreglo /
int insert_cell(int a[N],int n)
{
int pos, new;
char ch;
printf(“\nIngrese el elemento a insertar: “); scanf(“%d”,&new);
printf(“\nIngrese la posición de inserción: “); scanf(“%d”,&pos);
for(i=n;i>=pos;i–)
a[i] = a[i-1];
a[pos-1] = new;
n++;

printf(“\n ¿Desea continuar..(y/n)?”);
ch = getche();
if(ch==’y’) insert_cell(a,n);
return n;
} / Para agregar elemento a un arreglo existente /
int append_cell(int a[N],int n)
{
int pos, new;
char ch;
printf(“\nIngrese el elemento a agregar: “);
scanf(“%d”,&new);
a[n] = new;
n++;
printf(“\n ¿Desea continuar..(y/n)?”);
ch = getche();
if(ch==’y’)append_cell(a,n);
return n;
} / Ordenar una lista de elementos de un arreglo en orden descendente /
void sort_list_descend(int a[N],int n)
{
int temp;
for(i=0;ifor(j=i;jif(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf(“\nLos elementos ordenados en orden descendente son…”);
} / Ordenar una lista de elementos de un arreglo en orden ascendente /
void sort_list_ascend(int a[N],int n)
{
int temp;
for(i=0;ifor(j=i;jif(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf(“\nLos elementos ordenados en orden ascendente son..”);
} / Para encontrar el más pequeño y el más grande de un arreglo existente /
void small_big(int a[N],int n)
{
int temp;
for(i=0;ifor(j=i;jif(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf(“\nEl elemento más pequeño es : %d”,a[n-1]);
printf(“\nEl elemento más grande es : %d”,a[0]);
} / Buscar un elemento en un arreglo /
void search(int a[N],int n)
{
int target, temp=0;
printf(“\n Ingrese el elemento a buscar: “);
scanf(“%d”,&target);
for(i=0;iif(a[i] == target)
{
printf(“\nEncontrado en la posición no. %d”,i+1);
temp = 1;
}
if(temp == 0)
printf(“\n No encontrado”);
} / Programa principal / / Para demostrar operaciones simples de arreglos /
#include
#include #define m 100
int main()
{
int a[m],n; char ch;
clrscr();
n = accept_values(a);
do
{
printf(“\n 1 - Append_cell”);
printf(“\n 2 - Delete_cell”);
printf(“\n 3 - Insert_cell”);
printf(“\n 4 - Sort_list_descend”);
printf(“\n 5 - Sort_list_ascend”);
printf(“\n 6 - Small_big”);
printf(“\n 7 - Search”);
printf(“\n 8 - Remove_list”);
printf(“\n 9 - Exit”);
printf(“\n Ingrese su elección: “);
ch = getche();
printf(“\n”);
switch(ch)
{
case ‘1’: n = append_cell(a,n); break;
case ‘2’: n = delete_cell(a,n); break;
case ‘3’: n = insert_cell(a,n); break;
case ‘4’: sort_list_descend(a,n); break;
case ‘5’: sort_list_ascend(a,n); break;
case ‘6’: small_big(a,n); break;
case ‘7’: search(a,n); break;
case ‘8’: n = 0; break;
case ‘9’: printf(“\nEsto terminará su programa.”); break;
}
display(a,n);
printf(“\n¿Desea ejecutar de nuevo..(y/n)?”);
ch = getche();
}
while(ch!=’9’);
return 0;
} |

2. Arreglos Bidimensionales

Un arreglo bidimensional es una colección de elementos en forma de fila y columna.
Un arreglo multidimensional puede aceptar las siguientes operaciones.

Un arreglo multidimensional se utiliza comúnmente en las áreas de matrices para entender tareas completas de la manera más sencilla.

FUNCIONES DE MATRIZ

| | / 50_menumat.c /
#define N 100
#define M 10
int i, j, r, c, r1, r2, c1, c2; / Leer los valores para una MATRIZ /
void read_matrix(int A[M][M])
{
printf(“\n¿Cuántas filas? “);
scanf(“%d”,&r);
printf(“\n¿Cuántas columnas? “);
scanf(“%d”,&c);
for(i=0;ifor(j=0;jscanf(“%d”,&A[i][j]);
} / Escribir los valores de una MATRIZ /
void disp_matrix(int A[M][M])
{
for(i=0;i{
for(j=0;jprintf(“%5d”,A[i][j]);
printf(“\n”);
}
} / Para encontrar la TRANSPOSE de una MATRIZ de CUALQUIER ORDEN /
void tra_matrix_1(int T[M][M],int A[M][M])
{
printf(“\nLa transposición de A es\n”);
for(i=0;i{
for(j=0;j{
T[i][j] = A[j][i];
printf(“%5d”,T[i][j]);
}
printf(“\n”);
}
} / Para SUMAR dos MATRICES ( posible, solo si son de ORDEN IGUAL ) /
void add_matrix(int C[M][M],int A[M][M],int B[M][M])
{
for(i=0;ifor(j=0;jC[i][j] = A[i][j] + B[i][j];
printf(“\nLa suma de A y B es”);
} / Para MULTIPLICAR MATRICES de CUALQUIER ORDEN ( siempre que sigan la REGLA DE MULTIPLICACIÓN DE MATRICES ) /
void mul_matrix_1(int C[M][M],int A[M][M],int B[M][M])
{
int k;
printf(“\nEl producto de A y B es.. ”);
printf(“\nMatriz C\n”);
for(i=0;i{
for(j=0;j{
C[i][j]=0;
for(k=0;kC[i][j] = C[i][j]+(A[i][k]B[k][j]);
printf(“%5d”,C[i][j]);
}
printf(“\n”);
}
} / Para RESTAR dos MATRICES ( posible, solo si son de ORDEN IGUAL ) /
void sub_matrix(int C[M][M],int A[M][M],int B[M][M])
{
for(i=0;ifor(j=0;jC[i][j] = A[i][j] - B[i][j];
printf(“\nLa diferencia de A y B es”);
} / Un programa impulsado por MENÚ para realizar operaciones de MATRIZ */
#include
#include
int main()
{
int A[M][M],B[M][M],C[M][M],T[M][M]; char ch;
clrscr( );
printf(“\nIngrese los elementos de la matriz A.. ”); read_matrix(A); r1=r; c1=c;
printf(“\n Matriz A\n”); disp_matrix(A);
printf(“\nIngrese los elementos de la matriz B.. ”); read_matrix(B); r2=r; c2=c;
printf(“\n Matriz B\n”);disp_matrix(B);
do {
printf(“\n1:Suma”);
printf(“\n2:Resta”);
printf(“\n3:Multiplicación”);
printf(“\n4:Transposición”);
printf(“\n5:Salir”);
printf(“\nIngrese su elección..”); ch = getche();
switch(ch)
{
case ‘1’:
if(r1==r2 && c1==c2)
{
add_matrix(C,A,B);printf(“\nMatriz C\n”);
disp_matrix(C);
}
else
{
printf(“\nLos valores ingresados de r1,r2 && c1,c2 no son iguales,”);
printf(“\nhence no puedo hacer esta Suma de Matrices.”);
printf(“\nPor favor ingrese las matrices correctas.”);
} break;

case ‘2’:
if(r1==r2 && c1==c2)
{
sub_matrix(C,A,B);printf(“\nMatriz C\n”);
disp_matrix(C);
}
else
{
printf(“\nLos valores ingresados de r1,r2 && c1,c2 no son iguales,”);
printf(“\nhence no puedo hacer esta Resta de Matrices.”);
printf(“\nPor favor ingrese las matrices correctas.”);
} break;

case ‘3’:
if(c1==r2)
mul_matrix_1(C,A,B);
else
{
printf(“\nLas columnas(c1) de la Matriz A NO SON IGUALES A”);
printf(“ Las filas(r2) de la Matriz B.”);
printf(“\nPor lo tanto no puedo hacer esta Multiplicación de Matrices.”);
printf(“\nPor favor ingrese matrices tales que c1 == r2.”);
} break;

case ‘4’:   printf(“\nEl orden de la Matriz A es %d x %d”,r1,c1);
tra_matrix_1(T,A);
printf(“\nEl orden de la transposición de A es %d x %d”,c1,r1); break;

case ‘5’: printf(“\nEsto terminará su programa.”); break;
}
printf(“\n¿Desea ejecutar de nuevo…[y/n]? “); ch=getche();
}while(ch!=’5’);
return 0;
}