Está en la página 1de 6

RESUMEN DE ARREGLOS.

Un Arreglo es una estructura de datos que almacena bajo el mismo nombre


(variable) a una colección de datos del mismo tipo.

Los arreglos se caracterizan por:


 Almacenan los elementos en posiciones contiguas de memoria
 Tienen un mismo nombre de variable que representa a todos los
elementos. Para hacer referencia a esos elementos es necesario utilizar un
índice que especifica el lugar que ocupa cada elemento dentro del
archivo.

Tipo de Arreglos:
 Unidimensionales (Vectores).
 Bidimensionales (Matrices).

Ejemplos de arreglos Unidimensionales (Vectores).

1) Inicializar un arreglo.

#include <stdio.h>
int main(){
int n[ 10 ]; /* n es un arreglo de 10 enteros */
int i; /* contador */

/* inicializa los elementos n a 0 del arreglo */


for ( i = 0; i < 10; i++ ) {
n[ i ] = 0; /* establece el elemento i-esimo a 0 */
}

printf( "Elemento Valor\n" );

/* muestra el contenido del arreglo n en forma tabular */


for ( i = 0; i < 10; i++ ) {
printf( "%5d%13d\n", i, n[ i ] );
}
return 0;
}

2) Inicializar un arreglo mediante una lista.

#include <stdio.h>
int main(){
/* utiliza la lista para inicializar el arreglo n */
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
int i; /* contador */

printf( "Elemento Valor\n" );

/* muestra el contenido del arreglo en forma tabular */


for ( i = 0; i < 10; i++ ) {

1
printf( "%5d%13d\n", i, n[ i ] );
}
return 0;
}

3) Inicializa un arreglo con los múltiplos de 2.

#include <stdio.h>

int main(){
int s[10]; /* el arreglo s contiene 10 elementos */
int j;

for ( j = 0; j < 10 ; j++ ) { /* establece los valores */


s[ j ] = 2 + 2 * j;
}
printf( "Elemento Valor\n" );

/* muestra el contenido del arreglo s en forma tabular */


for ( j = 0; j < 10 ; j++ ) {
printf( "%5d%13d\n", j, s[ j ] );
}
return 0;
}

4) Inicializa un arreglo con valores leídos de teclado.

#include <stdio.h>

int main(){
int s[10]; /* el arreglo s contiene 10 elementos */
int j;

for ( j = 0; j < 10 ; j++ ) { /* establece los valores */


printf("Elemento %d: ", j);
scanf("%d",&s[j]);
}
printf( "Elemento Valor\n" );

/* muestra el contenido del arreglo s en forma tabular */


for ( j = 0; j < 10 ; j++ ) {
printf( "%5d%13d\n", j, s[ j ] );
}
return 0;
}

Ejemplos de arreglos Bidimensionales (Matrices).

1) Inicializar una Matriz.

#include <stdio.h>

int main(){
int m[3][4]; /* m es una matriz de 3(filas)x 4(Columnas) enteros */

2
int i,j; /* subindices */

/* inicializa los elementos de m a 0 */


for ( i = 0; i < 3; i++ ) {
for(j = 0; j < 4; j++){
m[ i ][ j ] = 0; /* establece el elemento a 0 */
}
}

/* muestra el contenido en forma tabular */

printf( "En Forma Tabular ---->\n" );


printf( "Elemento Valor\n" );
for ( i = 0; i < 3; i++ ) {
for (j = 0; j<4; j++){
printf("m[%d][%d]= %d\n",i,j,m[ i ][ j ] );
}
}

/* muestra el contenido en forma matricial */

printf( "En Forma Matricial ---->\n" );


for ( i = 0; i < 3; i++ ) {
for (j = 0; j<4; j++){
printf("%d",m[ i ][ j ] );
}
printf("\n");
}
return 0;
}

2) Inicializar una matriz mediante una lista.

#include <stdio.h>

int main()
{
int m[3][4]= {{9,8,7,6}, {5,4,3,2},{1,9,8,7}};
int i,j; /* subindices */

/* muestra el contenido en forma tabular */


printf( "En Forma Tabular ---->\n" );
printf( "Elemento Valor\n" );
for ( i = 0; i < 3; i++ ) {
for (j = 0; j<4; j++){
printf("m[%d][%d]= %d\n",i,j,m[ i ][ j ] );
}
}

/* muestra el contenido en forma matricial */


printf( "En Forma Matricial ---->\n" );
for ( i = 0; i < 3; i++ ) {
for (j = 0; j<4; j++){
printf("%d",m[ i ][ j ] );
}
printf("\n");

3
}
return 0;
}

3) Inicializa una matriz con valores leídos de teclado.

#include <stdio.h>

int main()
{
int m[3][4];
int i,j; /* subindices */

for ( i = 0; i < 3; i++ ) {


for(j = 0; j < 4; j++){
scanf("%d",&m[ i ][ j ]); }
}

/* muestra el contenido del arreglo n en forma tabular */


printf( "En Forma Tabular ---->\n" );
printf( "Elemento Valor\n" );
for ( i = 0; i < 3; i++ ) {
for (j = 0; j<4; j++){
printf("m[%d][%d]= %d\n",i,j,m[ i ][ j ] );
}
}

/* muestra el contenido del arreglo n en forma matricial */


printf( "En Forma Matricial ---->\n" );
for ( i = 0; i < 3; i++ ) {
for (j = 0; j<4; j++){
printf("%d",m[ i ][ j ] );
}
printf("\n");
}
return 0;
}

Muestra el histograma de un arreglo.

#include <stdio.h>
#define TAMANIO 10

int main(){
int n[ TAMANIO ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
int i; /* contador externo para el arreglo elementos */
int j; /* contador interno cuenta *s en cada barra del histograma */

printf( "%s%13s%17s\n", "Elemento", "Valor", "Histograma" );

/* para cada elemento del arreglo n, muestra una barra en el


histograma */
for ( i = 0; i < TAMANIO; i++ ) {
printf( "%7d%13d ", i, n[ i ]) ;
for ( j = 1; j <= n[ i ]; j++ ) { /* imprime una barra */
printf( "%c", '*' );

4
}

printf( "\n" ); /* fin de una barra del histograma */


}
return 0;
}

Paso de un arreglo a una función.

El arreglo pasa siempre como una referencia, esto quiere decir que no se hace un
copia del arreglo, sino que la función trabaja directamente con el arreglo
original y puede moficarlo.

Es común, útil y recomendable, pasar también como argumento el tamaño del


arreglo, para que la función pueda tratarlo y no se vaya fuera de los límites del
arreglo.

Un prototipo de función que recibe un arreglo.

void mostrarArreglo( int[],int);

Esta función recibe un arreglo de tipo int, el tamaño del arreglo y no devuelve
ningún valor.

La definición:

void mostrarArreglo(int arr[], int tamano) {


for (int i = 0; i < tamano; i++)
printf(“%d\n”, arr[i]);
}

Como vemos, pasar el tamaño del arreglo como argumento, no es algo trivial, ya
que sino la función no sabría hasta donde mostrar los elementos del arreglo.

5
EJERCICIOS DE ARREGLOS.

1.- Dado un arreglo de números enteros, mostrar los elementos únicos (que se encuentran
una vez en el arreglo)
2.- Dado un arreglo de números enteros, mostrar los elementos no únicos (que se encuentran
más de una vez en el arreglo)
3.- Dado un arreglo de números enteros, mostrar la cantidad de veces que se repite cada
valor en un arreglo.
4.- Dado un arreglo de números enteros, obtener un arreglo con los elementos ordenados de
mayor a menor.

5.- Dado un arreglo de números enteros, obtener un arreglo que contenga los números pares
y posteriormente los impares.
6.- Dado un arreglo de números enteros, obtener un arreglo que contenga alternadamente
los pares e impares en la medida que sea posible.

7.- Dado dos arreglos, genere un tercer arreglo que corresponda a la intersección de los
elementos de los arreglos originales (los elementos deben estar una sola vez).

8.- Dado dos arreglos, genere un tercer arreglo que corresponda a la unión de los elementos
de los arreglos originales (los elementos deben estar una sola vez en el arreglo resultante)

9.- Dado dos arreglos (A y B), genere un tercer arreglo que corresponderá a todos los
elementos de A que no se encuentran en B (deben estar una sola vez en el arreglo
resultante)

10.- Dado un arreglo ordenado, y un elemento, confeccione un programa que permita


determinar si el elemento se encuentra en el arreglo y en que posición.
11.- Dado dos arreglos ordenados, confeccione un tercero ordenado a partir de los anteriores,
pero sin realizar un proceso de ordenamiento sobre el arreglo final.
12.- Dado un arreglo, determine si este es palindrómico.

13.- Dado dos arreglos que contiene 0 y 1, confeccione un programa que permita generar un
tercer arreglo que corresponderá a la suma binaria de los elementos de los arreglos (los
largos de los arreglos son de largo N y M)
14.- Dado dos arreglos de números enteros, agrupe cada arreglo de tal forma que en un
arreglo se almacenen los números pares y en otro los números pares.