• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Arreglos
 

Arreglos

on

  • 6,704 views

 

Statistics

Views

Total Views
6,704
Views on SlideShare
6,690
Embed Views
14

Actions

Likes
2
Downloads
147
Comments
0

1 Embed 14

http://www.educlic.net 14

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Arreglos Arreglos Presentation Transcript

    • ARREGLOS (ARRAYS)
      • Un arreglo es una colección de datos del mismo tipo que se referencian por un mismo nombre, sus elementos se distinguen entre si, por índices o direcciones de memoria. A un elemento específico de un arreglo se accede mediante índices o su dirección de memoria. La dirección mas baja corresponde al primer elemento y la dirección mas alta al último elemento.
      • Los arreglos se clasifican por el numero de índices de acceso a los elementos en: Unidimensionales, bidimensionales y multidimensionales
      Ing. Rosario Coral H.
    • Arreglos Unidimensionales
      • Un arreglo unidimensional es una colección de datos del mismo tipo almacenados en posiciones contiguas de memoria.
      • Declaración: tipo nombre _arreglo[tama ño ];
      • Donde - tipo, declara el tipo base del arreglo,
      • que es el tipo de cada elemento del mismo
      • - nombre_arreglo, es el nombre del arreglo.
      • - tama ño, es el nro. de elementos del arreglo.
      • Ejemplo:
      • int lista[10]; // declara un arreglo lista con 10 elementos de tipo int.
      Ing. Rosario Coral H. 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 34 15 7 9 3 11 6 25 4 18 Indice EF00 EF02 EF04 EF06 EF08 EF10 EF12 EF14 EF16 EF18 Dirección Memoria Elementos lista
    • Arreglos Unidimensionales
      • Indice:
      • Identifica la posición del elemento en el arreglo. También se le conoce como subíndice. Deben ser enteros: constantes, variables o expresiones. El primer valor comienza generalmente por 0.
      • Los elementos del arreglo lista del ejemplo serian:
      • lista[0] = 34 primer elemento del arreglo
      • lista[1] = 15 segundo elemento del arreglo
      • …… .. …
      • lista[9] = 18 último elemento del arreglo
      Ing. Rosario Coral H. 0 1 2 3 4 5 6 7 8 9 34 15 7 9 3 11 6 25 4 18 Indice EF00 EF02 EF04 EF06 EF08 EF10 EF12 EF14 EF16 EF18 Dirección Memoria Elementos lista
    • Arreglos Unidimensionales
      • La declaración de los arreglos puede ser de cualquier tipo de datos por ejemplo:
      • int patos[22]; /*arreglo de 22 enteros */
      • char alfabeto[26]; /*arreglo de 26 caracteres*/
      • long int grados[500] /*arreglo de 500 enteros largos*/
      • También se puede usar constantes para la declaración de un arreglo
      • Ejemplos: #define TAM 15
      • int a[TAM];
      • char b[TAM+1];
      • float c[TAM-1]
      • La cantidad de memoria necesaria para almacenar un arreglo esta directamente relacionada con el tamaño y el tipo del arreglo
      • Total_bytes=sizeof(tipo)*tamaño
      Ing. Rosario Coral H.
    • Arreglos Unidimensionales
      • Inicialización de Arrays
      • Los arrays se Inicializan en el momento de declararlos,
      • La forma general de inicialización de un array es similar a la de otras "variables”, así:
      • tipo nombre_array[tamaño] = {lista _ valores} ;
      • donde: lista _ valores es una lista de constantes separadas por comas, cuyo tipo es compatible con tipo.
      • Ejemplo: int lista[10]={34,15,7,9,3,11,6,25,4,18};
      • La primera constante se coloca en la primera posición del array, la segunda constante se coloca en la segunda posición, y así sucesivamente.
      Ing. Rosario Coral H.
    • Arreglos Unidimensionales
      • Elaborar un programa que acepte números enteros como datos de entrada, los almacene en un arreglo y calcule su promedio y el valor máximo de estos datos
      • El tamaño del arreglo será fijado por el programador y deberá ser validado previamente en caso de que el número de datos supere el tamaño del arreglo. Además se debe indicar la finalización de la entrada de los datos
      Ing. Rosario Coral H.
    • Arreglos Unidimensionales Ing. Rosario Coral H. #include <stdio.h> #define TAM 50 int valor[TAM]; int cont=0,i,temp,maximo; float suma=0,prom=0; char resp=‘s’; void main() { do{ if (cont<TAM) {printf(“Ingrese el dato %d”,cont+1); scanf(“%d”,&valor[cont]); } else{ printf(“n No caben mas datos”); break;} cont++; printf(“nDesea ingresar mas datos?”); scanf(“%c”,&resp); }while(cont<TAM && resp!=‘n’); printf(“nHa introducido %d datos”,cont); printf(“nLos datos leidos son”); for(i=0;i<cont;i++) printf(“%5d”,valor[i]); /*Calcula el promedio*/ for(i=0;i<cont;i++) suma+=valor[i]; prom=suma/cont; printf(“nEl promedio de los numeros es %.2f”,prom); /*Determina el numero mayor*/ for(maximo=valor[0],i=1;i<cont;i++) if (valor[i]>maximo) maximo=valor[i]; printf(“nEl numero maximo es %d”,maximo); } //cierra el main
    • Arreglos Unidimensionales
      • Inicialización de Arrays Indeterminados
      • Los arrays indeterminados se denominan también arrays “ sin tamaño&quot; o &quot;no delimitados&quot;. El lenguaje C calcula automáticamente la dimensión de estos arrays al inicializarlos.
      • Un &quot;array indeterminado&quot; se tiene cuando en la sentencia de declaración de un array no se especifica el tamaño, creándose automáticamente un array para mantener todas las inicializaciones presentes. Es decir, de acuerdo a las constantes inicializadas se reserva el tamaño de memoria para dicho array.
      • Ejemplo: int lista[ ]={34,15,7,9,3,11,6,25,4,18};
      Ing. Rosario Coral H.
    • ARREGLOS UNIDIMENSIONALES
      • Punteros a arrays Unidimensionales
      • Los programas que utilizan punteros son más eficientes, porque los punteros usan directamente las direcciones de memoria, como usan las instrucciones de hardware. En particular, los punteros hacen más rápido el trabajo que los arrays. Entonces, la notación con arrays es un método disfrazado de empleo de punteros.
      • El nombre de un array sin Índice y sin corchetes es un puntero dirigido al primer elemento del array. Por ejemplo, con las siguientes declaraciones:
        • int meses[12];
        • int *p;
      • se puede generar un puntero al primer elemento, usando el nombre del array meses así:
        • p = meses;
      • Por lo tanto, se cumple que:
        • p == &meses[0]
      • es cierto, y los punteros meses y &meses[0] representan la dirección de memoria del primer elemento del array.
      • Además, los punteros meses y &meses[0] son constantes y no pueden cambiar su valor a lo largo del programa, porque indican dónde comienza a almacenarse el array. Sin embargo, pueden ser asignados a una &quot;variable puntero&quot; como p.
      Ing. Rosario Coral H.
    • Ing. Rosario Coral H. El lenguaje C proporciona dos métodos de acceso a elementos de arrays, que son: 1. Aritmética de punteros. 2. Indexación del array INDICES PUNTEROS Con el array meses Con el puntero p Primer elemento meses[0] *meses *p Segundo elemento meses[1] *(meses+1) *(p+1) Tercer elemento meses[2] *(meses+2) *(p+2) Duod écimo elemento meses[11] *(meses+11) *(p+11)
      • En el ejemplo anterior la variable puntero p quedará apuntando al primer elemento. Sin embargo, se puede también acceder a los elementos incrementando la variable puntero en un ciclo:
          • for (i=0,p=meses;i<12; i++,p++){
          • printf(“Ingrese el elemento %d”, i);
          • scanf(“%d”,p);
      • }
      Ing. Rosario Coral H.
    • Ing. Rosario Coral H. Indexación de Punteros Cualquier variable puntero que tenga la dirección del primer elemento de un array unidimensional, puede indexarse como si estuviera declarada como un array. esto se muestra a continuación: int *p, a[10l; p = a: p[5l = 100; 1* Asignación usando índice. */ *(p+5)= 100; /* Asignación usando aritmética de punteros. Ambas sentencias de asignación ponen el valor 100 en el sexto elemento del arreglo a.
      • Paso de Arreglos Unidimensionales a Funciones
      • En lenguaje C no se puede pasar un arreglo completo como argumento a una función. Sin embargo, se puede pasar a una función un puntero al primer elemento del arreglo, especificando el nombre del arreglo sin Índice.
      • Esto significa que la declaración del parámetro de la función debe ser de un tipo puntero compatible al puntero del arreglo. Por ejemplo, si se tiene el siguiente esqueleto de programa:
        • void main ()
        • {
        • int edad[50];
        • convierte (edad);
        • }
      • Para que una función reciba un arreglo unidimensional, se puede declarar el parámetro de la función de tres formas:
      • 1. Como un array indeterminado.
      • 2. Como un puntero.
      • 3. Como un array delimitado
      Ing. Rosario Coral H.
      • Como Array indeterminado. Es una versión modificada de la declaración del arreglo; simplemente especifica que se va a recibir en la función la dirección del arreglo de un tipo dado de cierta longitud, así:
        • void convierte (int prima[]) /* prima es un puntero a array. */
        • {
        • /*.... *1
        • }
      • El array edad tiene 50 elementos, pero prima es un puntero al primer elemento de array edad.
      • La declaración del parámetro:
        • int prima[]
        • no crea un arreglo sino un puntero, porque en la llamada a la función:
        • convierte (edad);
      • el argumento edad es un &quot;puntero&quot; al primer elemento de los 50 elementos del arreglo; por lo tanto, la llamada de la función pasa un puntero a la función convierte().
      Ing. Rosario Coral H.
      • 2. Como un Puntero
      • La llamada de la función pasa a la misma una dirección que va a ser recibida en un puntero asi:
            • void convierte (int *prima) /* prima es un puntero a array. */
            • {
            • /*.... *1
            • }
      • Entonces en la función convierte se puede trabajar en el arreglo de forma indexada o con “aritmética de punteros”.
      • Por lo tanto, son sinónimos las declaraciones de los siguientes parámetros
        • int prima[];
        • int *prima;
      • Ya que ambas definen prima como un puntero a entero. La principal diferencia es que prima[] apunta a un arreglo y la otra es una variable puntero.
      Ing. Rosario Coral H.
      • Como un Array delimitado
      • Consiste en la declaración estandar del arreglo como parámetro de la función, de la siguiente forma:
          • void convierte (int prima[50])
          • {
          • /*.... *1
          • }
      • Este método no es aconsejable, porque da la idea de crear un nuevo arreglo prima de 50 elementos de tipo int, en el que solo se pasa un puntero a un arreglo
      Ing. Rosario Coral H.
      • Conclusiones
      • El resultado de los tres métodos de declaración de los parámetros de la función es idéntico, porque cada uno le indica al compilador que se va a recibir un puntero a entero. Además en lo que a la función se refiere, no importa la longitud del arreglo ya que el lenguaje C no comprueba sus limites.
      • Cuando se emplea el nombre de un arreglo que es un puntero como argumento de una función, por lo que se puede realizar cambios en el arreglo original del programa del cual partió la llamada.
      Ing. Rosario Coral H.
    • Arreglos Bidimensionales (Matrices)
      • Un array bidimensional es un arreglo de dos arreglos unidimensionales.
      • Por ejemplo, para declarar un array bidimensional cuadro que tiene un array principal de 3 arrays unidimensionales, que a su vez tienen 4 elementos enteros, se haría:
      • int cuadro[3][4];
      • También se puede visualizar a un array bidimensional como una &quot;matriz&quot; con filas y columnas; el primer índice indica la fila y el segundo indica la columna. En donde al variar el primer indice, se accesa al array a lo largo de una columna, y al variar el segundo indice, se accesa por una fila
      Ing. Rosario Coral H.
    • Ing. Rosario Coral H. La representación gráfica del arreglo cuadro es: COLUMNAS [0] [1] [2] [3] F I [0]         L [1]         A [2]         S
    • Ing. Rosario Coral H. Para acceder al elemento de la fila 1 columna 2 del arreglo cuadro seria: cuadro[1][2] Los elementos del arreglo bidimensional cuadro seria cuadro [0][0] cuadro [0][1] cuadro [0][2] cuadro [0][3] cuadro [1][0] cuadro [1][1] cuadro [1][2] cuadro [1][3] cuadro [2][0] cuadro [2][1] cuadro [2][2] cuadro [2][3]
      • #include <stdio.h>
      • #define MAX_FILA 100
      • #define MAX_COL 100
      • int a[MAX_FILA][MAX_COL];
      • int i,j,fila,columna;
      • void main()
      • {
      • do{
      • printf(“Ingrese el numero de filas”);
      • scanf(“%d”,&fila);
      • }while(fila<=0 || fila > MAX_FILA);
      • do{
      • printf(“Ingrese el numero de columnas”);
      • scanf(“%d”,&columna);
      • }while(columna<=0 || columna > MAX_COL);
        • /* Ingreso de Elementos */
        • printf(“nIngreso de elementos”);
        • for (i=0; i<fila; i++)
        • for (j=0; j<columna; j++)
        • {
        • printf(“a[%d][%d]=”,i,j);
        • scanf(“%d”,&a[i][j]);
        • }
        • /* Imprime en forma matricial */
        • printf(“n Elementos de la matriz “);
        • for (i=0; i<fila; i++)
        • {
        • for (j=0; j<columna; j++)
        • printf(“%d”,a[i][j]);
        • printf(“n”);
        • }
      • }
      Ing. Rosario Coral H.
    • Arreglos Bidimensionales
      • Inicialización de Array Bidimensional
      • Se realiza colocando las constantes de cada fila entre llaves, a su vez las filas están encerradas entre otro par de llaves más externas. Es decir, como las filas de un array bidimensional son arreglos unidimensionales, las constantes dentro del primer par de llaves se asignan a la primera fila del array, las del segundo par a la segunda fila, y así sucesivamente.
      • Las reglas que controlan el número de constantes cuando no coincide con el tamaño del array, son las mismas que para arrays unidimensionales, así:
      • 1) Si dentro de un par de llaves “faltan&quot; constantes y el array es static o extern, los elementos son inicializados por defecto al valor 0, y a cualquier valor si el array es auto.
      • 2) Si hay &quot; demasiadas&quot; constantes se produce un error, y las que restan no servirán para inicializar la siguiente fila. Por ejemplo, en la declaración:
      Ing. Rosario Coral H.
      • Inicialización de arreglos Indeterminados Bidimensionales
      • En los arrays indeterminados bidimensionales las filas son indeterminadas, omitiendo el índice de las filas, porque el array bidimensional se almacena por filas, por lo que se debe especificar el número de elementos por cada fila, que corresponde al número de columnas del array. Esto sirve para construir tablas de longitudes variables, ya que el compilador asignará automáticamente el espacio necesario para las constantes a ser inicializadas.
      • Por ejemplo para crear un array de dos columnas: la primera es un número entero y la segunda su cuadrado, se declararía así:
      • Int cuad [][2]={
      • 1,1,
      • 2,4,
      • 3,9,
      • 4,16
      • };
      Ing. Rosario Coral H.
        • static int matriz[2][3] ={
        • {5,6},
        • {7,8}
        • };
        • se almacenará en el array matriz de la siguiente forma:
      • 5 6 0
      • 7 8 0
      • Al colocar solo el par de llaves externas sin colocar las internas, y el número de constantes es igual a la dimensión del array, la inicialización es correcta. Por el contrario, si se hubiera colocado menos constantes, el array se llena sin considerar la distribución en filas, terminando la inicialización del resto de elementos con ceros o basura. Por ejemplo, en la declaración:
      • static int matriz[2][3] = {5, 6,7, 8};
        • se almacenará en el arreglo matriz de la siguiente forma:
        • 5 6 7
        • 8 0 0
      • Las reglas para inicializar un array unidimensional cumple para un array bidimensional y viceversa.
      Ing. Rosario Coral H.