ARREGLOS UNIDIMENSIONALES

Vista previa del material en texto

ARREGLOS UNIDIMENSIONALES
1.1.-ARREGLOS
Un arreglo o array (en inglés) es una colección de variables relacionadas a las que se hace referencia por medio de un nombre común. Otra definición valida es que un arreglo es un conjunto de datos que se almacenan en memoria de manera contigua con el mismo nombre y para diferenciar los elementos de un arreglo se utiliza un índice. En el lenguaje C los arreglos son datos compuestos, que pueden tener una o varias dimensiones, a continuación se muestra como ejemplo la representación gráfica de un arreglo unidimensional (Arreglo de una dimensión).
	1
	arreglo[Ø]
	2
	arreglo[1]
	3
	arreglo[2]
	4
	arreglo[3]
	5
	arreglo[4]
	6
	arreglo[5]
float arreglo[6];
1.1.1.-ÍNDICE DE UN ARREGLO.
Los arreglos están compuestos por un número definido de elementos, de tal manera que para indicar la posición de estos en el arreglo, se utiliza un índice como elemento de correlación. Los índices en C van desde la posición 0 hasta la posición tamaño – 1.
1.1.2.-ELEMENTOS DE UN ARREGLO.
Un elemento de un arreglo es un valor particular dentro de la estructura del arreglo. Para acceder a un elemento del arreglo es necesario indicar la posición a través del índice dentro del arreglo.
 Ejemplo 1.1
• arreglo[Ø] /*Primer elemento del arreglo*/
• arreglo[3] /*Cuarto elemento del arreglo*/
1.2.-Arreglos unidimensionales
Un arreglo de una dimensión es una lista de variables, todas de un mismo tipo a las que se hace referencia por medio de un nombre común. Una variable individual del arreglo se llama elemento del arreglo. Para declarar un arreglo de una sola dimensión se usa el formato general:
tipo_dato identificador[tamaño];
int A[1Ø];
float B[18Ø];
doublé C[5Ø];
Para ingresar un elemento específico del arreglo se teclea el número del elemento. En C todos los arreglos empiezan en 0, esto quiere decir que si se desea acceder al primer elemento del arreglo debe usar el índice igual a Ø. Para ingresar un arreglo se especifica el índice del elemento que interesa dentro de un corchete, por ejemplo: valor= A[1];
Los arreglos empiezan en Ø, de manera que el índice 1 se refiere al segundo elemento. Para asignar el valor a un elemento de un arreglo, escribimos el elemento en el lado izquierdo de una sentencia de asignación por ejemplo:
A[Ø] =1ØØ;
C almacena arreglos de una sola dimensión en una localización de memoria contigua con el primer elemento en la posición mas baja. De esta manera, A[0] es adyacente a A[1], que es adyacente a A[2], y así sucesivamente, como se puede ver a continuación.
	Ø 
	Ø 
	Ø 
	Ø 
	Ø 
	Ø 
	Ø 
	Ø 
	A[Ø]
	A[1]
	A[2]
	A[3]
	A[4]
	A[5]
	A[6]
	A[7]
El valor de un elemento perteneciente a un arreglo puede ser empleado en sustitución de una variable sencilla o una constante. A continuación se muestra la forma en que se declara un arreglo de una dimensión y el significado de cada una de sus partes. 
int cuad[3]; /* forma un arreglo de una dimensión y de tres elementos, con el 
 nombre :cuad, y cuyos elementos son:
 cuad[0] → primer elemento
 cuad[1] → segundo elemento
 cuad[2] → tercer elemento*/.
Ejemplo 1.2.-El programa al recibir un arreglo unidimensional de tipo entero y un número entero, determina cuántas veces se encuentra el entero en el arreglo.
#include <stdio.h>
#include <conio.h>
int main ()
{
int i,num,cont= Ø;
int ele[5Ø];
for i=Ø; i<5Ø;i++)
{
printf(“\n\tIngrese el elemento %d del arreglo: “,i);
scanf(“%d”,&ele[i] );
}
printf(“\n\tIngrese el número que se va a buscar en el arreglo: “);
scanf(“%d”,&num );
for i=Ø; i<5Ø;i++)
if ( ele[i] ==num);
cont++;
printf(“\n\tEl %d se encuentra %d veces en el arreglo “,num,cont “);
getch();
return Ø;
}
Ejemplo 1.3.-En la elección para determinar al mejor jugador de futbol en un país se denominan a 3Ø candidatos.
Construya un programa que lea los votos de los candidatos y emita la cantidad que obtuvo cada uno de ellos.
#include <stdio.h>
#include <conio.h>
int main ()
{
int i,vot; /*Declaración del contador i y de la variable vot*/
int jug[3 Ø]=Ø; /*Declaración del arreglo entero jug de 30 elementos, cada uno 
 empieza desde cero*/
printf(“\n\tIngrese el primer voto - Ø para terminar- :“);
scanf(“%d”,&vot );
while (vot)
{
If ((vot> Ø) && (vot<5Ø)) /* Verifica que el voto sea correcto*/
jug[vot - 1]++; /*Se resta el uno debido a que el arreglo almacena los datos 
 desde el registro cero y de esa manera inicia el conteo, nosotros lo 
 hacemos nosotros al contar*/
else
printf(“\n\tVoto inválido elija otro candidato “);
printf(“\n\tIngrese el siguiente voto - Ø para terminar-“);
scanf(“%d”,&vot );
}
printf(“\n\tEl resultado de la elección “);
for i= Ø ; i<29;i++)
if ( ele[i] ==num);
cont++;
printf(“\n\tEl candidato %d: obtuvo %d votos “,i+1, jug[i] );
getch();
return Ø;
} 
1.3.-APUNTADORES Y ARREGLOS.
Un apuntador es una variable que tiene la dirección de otra variable y se representa por los signos de dirección (&) e indirección (*).
El símbolo & sirve para proporcionar la dirección de un objeto.
El símbolo * sirve para accesar al objeto del cual se tiene la dirección.
Un arreglo se puede pasar a una función indicando el nombre del arreglo que es representado por un apuntador.
 Ejemplo 1.3.-Aplicación de apuntadores y arreglos.
#include <stdio.h>
#include <conio.h>
int main ()
{
Int x=3,y=7,z[5] ={2,4,6,8,10} ;
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
int *ix; /* ix representa un apuntador a un entero*/
ix=&x; /* ix apunta a x, ix tiene la dirección de ix*/
y=*ix; /* y toma el valor de x, ahora vale 3 */
*ix=1; /* x se modifica, ahora vale 1*/
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
ix=&z[2]; /*ix apunta al tercer elemento del arreglo z. */
y=*ix; /* y toma el valor de z[2], ahora vale 6 */
*ix=15; ; /* z[2] se modifica ahora vale 15 */
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
x=*ix+5; /*x se modifica, ahora vale z[2] + 5 =20;
*ix=*ix – 5; /*z[2] se modifica ahora vale 10.*/
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
++*ix; /*z[2] se modifica, se incrementa en 1, ahora vale 11.*/
*ix+=1; /*z[2] se vuelve a modificar, ahora vale 12.*/
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
x=*(ix+1); /* x se modifica el apuntador ix accede temporalmente a z[3], por lo tanto x toma este valor (8). Observa que ix no se reasigna*/
y=*ix; /* y se modifica, toma el valor de z[2] (12)*/
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
ix=ix+1; /*ix se modifica. Observa la forma de mover el apuntador. Ahora ix apunta al cuarto elemento de z (z[3]).*/
y=*ix; /* y se modifica ahora vale z[3] (8).*/
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
ix=ix+4; /*ix se modifica.Observa que el apuntador se mueve 4 posiciones y cae en una dirección fuera del arreglo. Esto ocasionara un error.*/
y=*ix; /* y se modifica y toma un valor de error, es un error que no marca el compilador*/.
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
ix=&x; /*ix apunta a la variable entera x.*/
ix=ix+1; /*ix se mueve en una posición y cae en una celda incorrecta*/
x=*ix; /* x toma el valor (basura) de la celda a la que apunta ix */
printf(“\n\tx=%d \ty=%d \t z[Ø]=%d \tz[1]=%d \tz[3]=%d \tz[4]=%d”,x,y, z[Ø], z[1], z[3], z[4]);
getch();
return Ø;
} 
1.4.-ARREGLOS Y FUNCIONES.
En la resolución de cierto tipo de problemas nos veremos en la necesidad de emplear funciones que utilizan arreglos, estos son llamados utilizando parámetros por referencia, así cada modificaciónhecha en el arreglo afectara el valor original de la función.
Cuando llamamos un arreglo a una función solo incluimos el nombre que en este caso es un apuntador, sin incluir los corchetes, ya que esto generara un error de sintaxis. 
Ejemplo 1.4.-El programa Obtiene el producto de dos vectores utilizando la técnica de arreglos unidimensionales , los vectores son de tipo entero y contienen cada uno 1Ø elementos, los arreglos están definidos como: ve1[10], ve2[10] y ve3[10], donde los dos servirán para ingresar los elementos de cada vector y el tercero se usara para el resultado de la operación].
#include <stdio.h>
#include <conio.h>
const int max=1 Ø ; /*Con esta constante definimos el tamaño del arreglo*/
int lec(int vec[ ],int t);
int imp(int vec[ ],int t);
int prod (int *x, int*y, int *z, int t); /* En los parámetros se puede escribir vec[ ], o 
 *vec */
int main ()
{
int ve1[max], ve2[max], ve3[max]; /* Declaración de los 3 arreglos a emplear */
lect (ve1,max); /*En la llamada de la función lect (lectura), solo se incluye el 
 nombre del arreglo */
lect (ve1,max
prod (ve1, ve2, ve3, max); /*llamada de la función prod (producto), observe que 
 se pasan los nombres de los tres arreglos. */
printf(“\n\tProducto de los vectores”);
imp(ve3, max);
getch ();
}
int lec(int vec[ ],int t);
{
int i;
printf(“\n\t”);
for( i= Ø; i<t;i++);
{
printf(“\n\tIngrese el elemento %d: “, i+1);
scanf ( “%d” , &vec [ i ] );
}
}
int imp(int vec[ ],int t);
{
int i;
for( i= Ø; i<t;i++);
{
printf(“\n\tvec [ %d ]: %d“ ,i+1, vec [ i ] );
}
int prod (int *x, int*y, int *z, int t); 
int i;
for( i= Ø; i<t;i++);
{
z [ i ] = x [ i ] * y [ i ];
}
Ejemplo 1.1.-El siguiente programa calcula las calificaciones de un grupo de 50 alumnos, obtiene la frecuencia de cada una de ellas e imprime la más alta.
#include <stdio.h>
#include <conio.h>
const int tam=5 Ø; /*Con esta constante definimos el tamaño del arreglo*/
int lec (int *, int);
int frec ( int, int, int, int); /* Prototipo de Funciones */
int imp (int *,int );
int may (int*, int);
int main ()
{
int cal[tam], frec[6] ={ Ø }; /*Declaración de los arreglos. */
lec(cal,tam); /* Llamada a la función lec (lectura)*/
frec (cal,tam,frec,6); ); /* Llamada a la función frec (frecuencia), se pasan 
 ambos arreglos*/
printf(“\n\tFrecuencia de calificaciones”);
imp(frec,6);
may(frec,6);
getch ();
}
int lec(int vec[ ],int t);
{
int i;
for( i= Ø; i<t;i++);
{
printf(“\n\tIngrese la calificación del alumno: %d: “, i+1);
scanf ( “%d” , &vec [ i ] );
}
}
int imp(int vec[ ],int t);
{
int i;
for( i= Ø; i<t;i++);
{
printf(“\n\tvec [ %d ]: %d“ ,i, vec [ i ] );
}
int frec ( int a [ ], int p, int b [ ], int t)
{
int I;
for ( i= Ø; i<t;i++);
if (( a [ i ]>=0) && ( a [ i ]<6)) /*Se valida que la calificación es correcta.*/
b [a [ i ] ]++; /*Aquí se almacenan las frecuencias*/
{
int I, mfre= Ø, mval [ ]
int prod (int *x, int*y, int *z, int t); 
int i;
}
int may (int *x, int t) /*Esta función obtiene la primera ocurrencia de la 
 frecuencia más alta.*/
{
int i, mfre= Ø, mval =x [Ø ];
for( i= Ø; i<t;i++);
if ( mval< x [ i ] )
{
mfre =I;
mval= x [ i ];
printf(“\n\n \tMayor frecuencia de calificaciones: %d \t Valor: %d”, mfre, mval);
}
EJERCICIOS DE REFORZAMIENTO
I.-Utilizando arreglos unidimensionales desarrolle los siguientes programas. 
1. Dado un arreglo de números desordenados, el programa imprimirá los números en forma ordenada, pero sin números repetidos.
2. Escriba un programa que al ingresarle un arreglo unidimensional de números enteros determine cuántos positivos, negativos y nulos existen.
3. Construya un programa empleando arreglos unidimensionales, que al ingresar las calificaciones de un grupo determine el promedio general de este, el porcentaje de aprobados y reprobados.
4. Se desea determinar la producción agrícola de trigo en la zona del bajío, elabora un programa que desplegué El promedio anual de toneladas cosechadas por estado, Los años donde la producción fue mayor y Los años donde fue menor.
5. Al recibir un arreglo ordenado en forma ascendente el programa imprimirá el mismo arreglo pero en forma descendente. 
6. Calcule la suma de dos vectores cualquiera.
7. Escribe un programa que determine la media y la moda de una serie de datos.
8. Al recibir un arreglo unidimensional de números reales, obtendrá como resultado la sume del cuadrado de los números.
9. Al recibir una serie de números almacenados en un arreglo unidimensional el programa imprimirá los primeros 100 números primos.
10. Al recibir una serie de números almacenados en un arreglo unidimensional el programa imprimirá lo números que son múltiplos de 3,7 y 9 respectivamente.