UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERÍA Y ARQUITECTURA

ESCUELA DE INGENIERÍA ELÉCTRICA
INTRODUCCIÓN A LA INFORMÁTICA

Asignacion 7 : ANSI C: ARREGLOS

Docente:
Ing. Walter Zelaya
Instructor:
Job Acosta
Alumnos:
Arias Argueta, Ernesto Alonso AA17001
Guzmán Azúcar, Elvin Javier GA15008
Reyes Ruano, José Miguel RR15057
Rodríguez Gonzales, José Roberto RG17012

GL: 06

Ciudad universitaria,1 de junio del 2018

 INTRODUCCION

Un arreglo es un conjunto de elementos del mismo tipo de datos agrupados

en una sola variable. También se le conoce como el nombre de arreglo
unidimensional ( vector o lista ) y bidimensional ( matrices o tablas)
Se verá como los arreglos pueden ser alimentados desde el teclado o desde
un archivo ya sea utilizando los elementos y el operador de dirección “&” o
por medio de punteros. Los arreglos son esenciales en aquellas aplicaciones
en las cuales se analizarán mucho datos de un mismo fenómeno.
Los arreglos son estructuras de datos que consisten en elementos de datos
del mismo tipo relacionados los arreglos son entidades de longitud fija
conservan la misma longitud una vez que se crean aunque puede
reasignársele una variable tipo arreglo de tal forma que haya referencia a un
nuevo arreglo de distinta longitud.
 OBJETIVOS
OBTETIVO GENERAL
 Comprender que es un arreglo en general, su correcta utilidad para
ponerlo en práctica al momento de programar
 Entender el método de la burbuja para poder resolver problemas
complejos en ANSI C.

OBTETIVO ESPECÍFICO
 Utilizar arreglos para la solución de problema.
 Relacionar punteros con arreglos
 Utilizar los arreglos en ANSI C para poder resolver problemas de
diversa índole.
 Conocer las características principales de los arreglos.
 ARREGLO

Es una colección de datos del mismo tipo. Sirve para manejar un número “n”
de elementos en común.

Un arreglo unidimensional es un tipo de datos estructurado que está

formado de una colección finita y ordenada de datos del mismo tipo. Es la
estructura natural para modelar listas de elementos iguales. El tipo de
acceso a los arreglos unidimensionales es el acceso directo, es decir,
podemos acceder a cualquier elemento del arreglo sin tener que consultar a
elementos anteriores o posteriores, esto mediante el uso de un índice para
cada elemento del arreglo que nos da su posición relativa.

Un arreglo unidimensional tiene una sola dimensión, También reciben el

nombre de vectores en álgebra.

Un arreglo se caracteriza por:

1. Almacenar los elementos del arreglo en posiciones de memoria contínua.

2. Tener un único nombre de variable que representa a todos los elementos,

y éstos a su vez se diferencian por un índice o subíndice.

3. Acceso directo o aleatorio a los elementos individuales del arreglo.

veamos como se agruparían estos 3 elementos en un solo arreglo:

private int []x = new int[3];
private int[]x = {1,2,3};
Operaciones con arreglos.

Las operaciones en arreglos pueden clasificarse de la siguiente forma:

• Lectura: este proceso consiste en leer un dato de un arreglo y asignar

un valor a cada uno de sus componentes
• Escritura: Consiste en asignarle un valor a cada elemento del arreglo.
• Asignación: No es posible asignar directamente un valor a todo el
arreglo
• Actualización: Dentro de esta operación se encuentran las operaciones
de eliminar, insertar y modificar datos. Para realizar este tipo de
operaciones se debe tomar en cuenta si el arreglo está o no ordenado.
• Ordenación.

Ordenaciones en Arreglos

La importancia de mantener nuestros arreglos ordenados radica en que es

mucho más rápido tener acceso a un dato en un arreglo ordenado que en
uno desordenado.

Existen muchos algoritmos para la ordenación de elementos en arreglos,

algunos de ellos son:

Selección directa

Este método consiste en seleccionar el elemento más pequeño de nuestra

lista para colocarlo al inicio y así excluirlo de la lista. Para ahorrar espacio,
siempre que vayamos a colocar un elemento en su posición correcta lo
intercambiaremos por aquel que la esté ocupando en ese momento.
¿Cómo declarar un arreglo?

Los elementos de un arreglo pueden ser inicializados en la declaración on del

arreglo haciendo seguir a la declaración on un signo de igual y una lista entre
llaves de valores separados por comas.
Por ejemplo

int n[10]={32, 27, 64, 18, 95, 24, 90, 70, 8, 3};

Si en la declaración hay menos inicializadores que el tamaño del array, los

elementos son inicializados a cero. Puedo entonces inicializar todo un array
en 0 con la declaración:

int n[10]={0};
Si en una declaración on con una l ista inicializadora se omite el tamaño del
arreglo el numero de elementos del arre lo ser a el numero de elementos
incluidos en la lista inicializadora.

Por ejemplo

int a1 [] ={1,2,3,4,5};

Crea un arreglo de 5 elementos. No se puede asignar un arreglo en otro, se

tiene que copiar posición a posición.

Operaciones frecuentes:
Recorrido de un arreglo de tamaño n: El indice puede ir del primero al ultimo
elemento:
for (i=0; i<n; i++)
{ proceso
}

El indice puede ir del ultimo al primer elemento

for (i=n-1 ; i>= 0 ; i–)

{ proceso
}

Relación entre arreglos y punteros.

Los punteros son variables cuyo valor es una dirección de memoria. Así, si
tenemos uno cuyo valor es 1234, decimos que apunta a la dirección 1234.
Como cualquier variable, un puntero está almacenado en una dirección de la
memoria, que además es distinta de aquella a la que apunta. En esta imagen
tenemos un puntero localizado en la dirección
1000, que hace referencia, o apunta, a la dirección 1234:

Cuando declaramos un puntero, únicamente se reserva memoria para él.

Antes de poder usarlo, debemos asegurarnos de que apunte a alguna
dirección correcta, ya sea reservándola de forma dinámica:

// C
int *ptr = malloc(numBytes);
// C++ int *ptr = new
int[numElementos];

o directamente haciendo que apunte a la dirección de alguna variable:

int n; int *ptr

= &n;

Un arreglo es una variable que contiene uno o más elementos. La dirección

del arreglo es la misma que la de su primer elemento. Veamos un arreglo de
4 int almacenado en la dirección 1000:
Como vemos en la imagen, arreg es todo el arreglo completo, y su tamaño es
el de todos sus elementos. A pesar de lo que a veces se lee, un arreglo no es
un puntero disfrazado, ni nada por el estilo. Es simplemente eso, un arreglo,
cuyo tipo viene determinado por la cantidad y tipo de elementos que
contiene. Así, en la siguiente declaración:

int arreg[4];

arreg es una variable cuyo tipo es arreglo de 4 int. Es importante

comprender bien esto, pues aunque en el lenguaje cotidiano podamos
describirlo simplemente como un arreglo de int, su tipo completo (de
manera que el compilador lo entienda) incluye el tamaño. A diferencia de los
punteros, cuando declaramos un arreglo, se reserva suficiente memoria para
todos sus elementos y está listo para usarse.

Tanto los arreglos como los punteros son lo que se conoce como tipos
derivados, porque se forman a partir de otros tipos. De esta manera
tenemos, por ejemplo, punteros a int, punteros a float, punteros a char,
arreglos de 4 int, arreglos de 4 float, arreglos de 6 int, etc.

Algunos manuales dicen que el nombre de un arreglo es un puntero a su

primer elemento, lo cual no es del todo cierto. Lo que en realidad sucede es
que, en casi todas las circunstancias, cuando escribimos una expresión de
tipo arreglo, el compilador la convierte a una expresión de tipo puntero, que
hace referencia a su primer elemento.

Un ejemplo de expresión de tipo arreglo es el nombre del arreglo sin índices:

arreg

Lo anterior se convierte a algo así:

&arreg[0]

En algunos casos podemos usar notación de punteros con los arreglos y

viceversa. Por ejemplo, en el siguiente código:

int *ptr = malloc(10 * sizeof(int));

ptr apunta a un bloque de memoria que contiene 10 objetos int. Es válido

hacer esto:

ptr[4] = 15;

La línea anterior modifica el int que se encuentra 4 posiciones más allá de la

dirección a la que apunta ptr. También podemos usar notación de punteros
con arreglos:
int arreg[10];
*(arreg+4) = 15;

es decir, arreg se convierte a puntero a la dirección a su primer elemento;

luego, se le suman 4 posiciones; después, el operador * indica que deseamos
acceder al valor de arreg+4 y no a su dirección; y finalmente lo modificamos.

De hecho, siempre que accedemos a algún elemento específico de un

arreglo, el compilador calcula su dirección de esa misma forma:
dirección_del_arreglo + índice. En el caso de un arreglo bidimensional, la
fórmula para encontrar la dirección de un elemento es:
dirección_del_arreglo + (num_de_fila * cantidad_de_columnas +
num_de_columna).

Antes de seguir, vamos a dejar algo en claro: cuando se dice que el nombre
del arreglo sin índices se convierte a puntero, nos referimos a un puntero
"conceptual". Aclaro esto porque se podría pensar que el compilador añade
punteros para cada uno de los arreglos que declaramos, lo cual no ocurre.
Sería un desperdicio de memoria, ya que los punteros, como cualquier otra
variable, ocupan espacio. Veremos a continuación lo que en realidad ocurre.
 PROCEDIMIENTO

PARTE 1a. Lectura desde el teclado.

/* Con este programa se trata de mostrar como asignar datos desde el
teclado a un arreglo. Recordar que JAMAS se debe sobre pasar la capacidad
del arreglo y por eso se utiliza el break. */
1. #include <stdio.h>
2. #define MAX 8 //Limite del arreglo
3. int main ( int argc, char * argv[ ] )
4. {
5. float A [ MAX ];
6. int indice = 0, p;
7. do if ( indice >= 8 ) break ;
8. else scanf ( "%f", A + indice++ );
9. while ( getchar ( ) != EOF ) ;
10. printf ( "\n\n\nIndice Dato Direccion\n" );
11. for ( p = 0 ; p < indice ; p++ )
12. printf ( "%4d%14.3g %10x\n", p, *( A + p ), A + p );
13. return 0;
14.} // fin main
PARTE 1b. Encontrar todas las diferencias, Con punteros o Sin punteros de
los siguientes programas:
Programa A:
1. #include <stdio.h>
1. int main ( int argc, char * argv[ ] )
2. {
3. float A [ MAX ];
4. int indice = 0, p;
5. do if ( indice > 8 ) break ;
6. else scanf ( "%f", A + indice++ );
7. while ( getchar ( ) != EOF ) ;
8. printf ("\nIndice Dato Direccion\n" );
9. for ( p = 0 ; p < indice ; p++ ) 10. printf ( "%4d%14.3g %10x\n", p,*( A + p ),
A + p );
11. return 0;
12.}

Programa B:
1. int main ( int argc, char * argv[ ] )
2. {
3. float A [ MAX ];
4. int indice = 0, p;
5. do if ( indice >= 8 ) break ;
6. else scanf ( "%f", & A [ indice++ ] );
7. while ( getchar ( ) != EOF ) ;
8. printf("\nIndice Dato Direccion\n" );
9. for ( p = 0 ; p < indice ; p++ ) 10. printf ( "%4d%14.3g %10x\n", p, A [ p ], &
A[ p ] );
11. return 0;
12. }
PARTE 2. Lectura desde archivo.
/* Con este programa se trata de mostrar como asignar datos desde el un
archivo a un arreglo. Recordar que JAMAS se debe sobre pasar la capacidad
del arreglo y por eso se utiliza el break. */
1. #include <stdio.h>
2. #define MAX 20 //Limite del arreglo
3. int main ( int argc, char * argv[ ] )
4. {
5. float A [ MAX ];
6. int indice = 0, p;
7. FILE *f;
8. if ( argc != 2 ) exit ( 1 );
9. else
10. {
11. f = fopen( argv[ 1 ], "r" );
12. for ( indice = 0; indice < MAX; indice++ )
13. fscanf( f, "%f", A + indice );
14. printf ( "\n\n\nIndice Dato Direccion\n" );
15. for ( p = 0 ; p < indice ; p++ ) 16. printf ( "%4d%14.3g %10x\n", p, *(A + p),
A + p );
17. } // fin if else
18. return 0;
19.}
Una solución sin punteros, es cambiando las siguientes líneas:
13. fscanf( f, "%f", & A[ indice ] ); 16. printf ( "%4d%14.3g %10x\n", p, A [ p ],
& A[ p ] );
PARTE 3. Método de la burbuja.
/* Este programa ordena un arreglo de mayor a menor utilizando el método
de la burbuja. */
#include <stdio.h>
#include <stdlib.h>
#define MAX 50
int main ( int argc, char * argv[ ] ) {
float A[ MAX ];
int indice, pasada, temp;
FILE *f;
if ( argc != 2 ) exit ( 1 );
else
{
f = fopen( argv [ 1 ], "r" );
for ( indice = 0 ; indice < MAX ; indice++ )
fscanf( f , "%f", A + indice );
printf ("\n\n Arreglo original\n\n");
for ( indice = 0 ; indice< MAX ; indice++ )
if ( !( indice % 10 ) ) printf ( "\n" );
else printf( "%8g ", * ( A + indice ) );
for ( pasada = 1 ; pasada < MAX ; pasada++ )
for ( indice = 0 ; indice < MAX-1 ; indice++ )
if ( A[ indice ] > A[ indice + 1 ] )
{
temp = A[ indice ] ;
A[ indice ] = A[ indice + 1 ];
A[ indice + 1 ] = temp;
}
printf ("\n\n Arreglo ordenado\n\n");
for ( indice= 0 ; indice < MAX ; indice++ )
if ( !( indice % 10 ) ) printf ( "\n" );
else printf( "%8g ", * ( A + indice ) );
fclose( f );
printf("\n");
}
return 0;
}
 ASIGNACIÓN
1. Utilizar el método de la burbuja, para ordenar un arreglo de números
reales y que se impriman de mayor a menor.

#include <stdio.h>

int main () {

int k=0,n,bandera;
float temp,A[20];
printf("Introduzca el número de datos, máximo 20: ");
scanf("%i",&n);

do{ printf("Introduzca el dato número %i: ",k+1);

scanf("%f",&A[k]); }while(++k<n);
do{ k=0;bandera=0;
do{ if(A[k]>A[k+1]) {
temp=A[k];
 A[k]=A[k+1];
A[k+1]=temp;
bandera=1; }
k++; }
while(k<n-1); }
while(bandera==1);
k=n-1;

do{ printf("%f\n",A[k]); k--; }

while (k>=0);

return 0;
}
2. Guardar en un arreglo los primeros 50 números primos, y después
estos datos poder guardarlos en un archivo local.

#include <stdio.h>
int main () {
int prim[50], i=0,counter=0 , k=3,a;
FILE *fp;
prim[0]=2;
fp = fopen("/home/jose/primes.txt", "w");
fprintf(fp,"%i) %i\n",counter+1,prim[counter]);
do{ do{ a=k%prim[i]; i++; }while (!(a==0) & i<counter);
if (!(a==0)) { counter++;
prim[counter]=k; fprintf(fp,"%i)
%i\n",counter+1,prim[counter]);
} k++; i=0;
}while (counter<49);
return 0;
}
 3. Utilizando arreglos y la regla del trapezoidal encontrar el área bajo la
curva. Elegir una función matemática y leer desde el teclado n, xo, xn.

#include <stdio.h>
#define DIM 500
int main (int argc, char * argv[]) {
int N,n,C;
float F [DIM], AR = 0.0, A, B;
printf ("\n Intro cantidad de subintervalos: ");
scanf ("%d", &N);
printf ("\n Intro Xo y Xn ");
scanf ("%f%f", &A, &B);
puts ("\n");
for ( C=0; C<N+1; C++) {
printf("f(%d) = ", C);
scanf ("%f", F+C);
}
AR= F[0]+ F[n];
 for ( C=1; C<N; C++) {
AR+= 2.*F[C];
AR*=(B-A)/2./N;
}
printf("\n El area bajo la curva es %f\n\n\n", AR);
return 0;
}
4. En un arreglo de 80 elementos asignar los números de Bernoulli. Es
decir que en el primer elemento deberá estar B1 en se segundo
elemento B2 y así sucesivamente. Además se debe imprimir en un
archivo en forma de tabla.

#include <stdio.h>
#define pi 3.14159265358979323846
#define E 0.000000000000001
int main(){
double mul,B[80],sum,temp;
int n=1,j=0,k=2;
FILE *fp;
fp = fopen("/home/jose/bernoulli.txt", "w");
double fac(int n){ int i; double fac=n;
for(i=n-1;i>1;i--){ fac=fac*i;
}
return fac;
}
double pot(double x, int k){ int i; double pote=x; for (i=1;i<k;i++){
pote=pote*x;
}
return pote; }
 do{ sum=1;temp=0;k=2;
mul=(fac(2*n))/(pot(2,(2*n-1))*pot(pi,2*n));
do{ sum=sum+temp;
temp=1.0/pot(k,2*n);
k++;
}
while(temp>E);
B[j]=sum*mul; j++; n++;
}while(j<80); j=0;
do{
fprintf(fp,"B%i\t %E\t B%i\t %E\t B%i\t %E\t B%i\t
%E\n",j+1,B[j],j+21,B[j+20],j+41,B[j+40],j+61,B[j+60]);
/* Para que los datos queden uniformes, de manera que se vea parecido
a una tabla,
limitamos la cantidad de dígitos con ayuda del formato de notación
científica*/
j++; }
while (j<20);
return 0;
}
 5. Por medio de un programa escrito en ANSI C guardar en un arreglo
los primeros 100 términos de la siguiente serie.

#include <stdio.h>
#define IT 100.0
int main ()
{
float A=1.0, B, C, D, E, F, SUM=0.0;
float N=1.0, DEN=2.0, POT=1.0, a, x, G;
printf("Introduzca el valor de a: ");
scanf("%f",&a);
 printf("Introduzca el valor de x: ");
scanf("%f", &x);
E= a/x;
for (G=0.0; G<IT; G++){
D= a/x;
B= NUM/DEN;
A*=B;
E= E*D*D;
C= E/(POT*POT);
F= A*C;
SUM+= F;
NUM+=2.0;
DEN+=2.0;
POT+=2.0;
}
SUM= (SUM+D)*(-1.0);
printf("La suma de los 100 terminos guardados es: %f\n", SUM);
return 0;
}
 CONCLUSIÓN

Se puede decir que los arreglos pueden variar dependiendo sus dimensiones
estos pueden ser unidimensionales y bidimensionales; a los primeros se les
conoce como vectores y como su nombre lo indica poseen una dimensión o
una lista de datos del mismo tipo y los bidimensionales poseen dos
dimensiones se usan para representar datos que pueden verse como una
tabla con filas y columnas y se les conoce como matrices

La codificación es algo tan simple como lo que realizamos a diario cuando

transformamos imágenes visuales o entidades conceptuales en palabras,
oraciones textos y las comunicamos a aquellos que nos rodean. Conocemos
a la codificación como cualquier operación que implique la asignación de un
valor de símbolos o caracteres a un determinado mensaje verbal o no verbal
con el propósito de transmitir a otros individuos o entidades que comparen
el código.