Capítulo 5

.
En C los arrays se numeran desde cero. Más allá de eso, el manejo de arrays es muy similar a Pascal.

testArrays1.1.c

   1:
   2:#include<stdio.h>
   3:
   4:int main()
   5:{
   6:   int arr[5];
   7:
   8:   arr[0]=2;
   9:   arr[1]=4;
  10:   arr[2]=6;
  11:   arr[3]=8;
  12:   arr[4]=10;
  13:
  14:   printf("valor del arr[0]=%d\n",arr[0]);
  15:   printf("valor del arr[1]=%d\n",arr[1]);
  16:   printf("valor del arr[2]=%d\n",arr[2]);
  17:   printf("valor del arr[3]=%d\n",arr[3]);
  18:   printf("valor del arr[4]=%d\n",arr[4]);
  19:}
  20:

También podemos dimensionar un array en función de una lista de valores como muestra el siguiente ejemplo:

testArrays1.2.c

   1:
   2:#include<stdio.h>
   3:
   4:int main()
   5:{
   6:   // podemos dimensionar y asignar valores
   7:   // automaticamente, solo al momento de
   8:   // definir el array
   9:   int arr[] = { 2, 4, 6, 8, 10 };
  10:
  11:   printf("valor del arr[0]=%d\n",arr[0]);
  12:   printf("valor del arr[1]=%d\n",arr[1]);
  13:   printf("valor del arr[2]=%d\n",arr[2]);
  14:   printf("valor del arr[3]=%d\n",arr[3]);
  15:   printf("valor del arr[4]=%d\n",arr[4]);
  16:}
  17:

En el siguiente ejemplo usamos un for para asignar valores al array y otro for para mostrar su contenido.

testArrays3.c

   1:
   2:#include<stdio.h>
   3:
   4:int main()
   5:{
   6:   int i;
   7:   int arr[5];
   8:
   9:   for( i=0; i<5; i++ )
  10:   {
  11:      // notemos que i comienza desde cero...
  12:      arr[i] = 2*(i+1);
  13:   }
  14:
  15:   for( i=0; i<5; i++ )
  16:   {
  17:      printf("valor del arr[%d] = %d\n",i,arr[i]);
  18:   }
  19:}
  20:

Al igual que en Pascal no podemos definir un array de n elementos siendo n una variable. Pero, llegado el caso podemos alocar n variables con direcciones de memoria consecutivas y así lograremos el mismo efecto. En definitiva estaremos creando un array de n posiciones.

testArrays4.c

   1:
   2:#include<stdio.h>
   3:
   4:int main()
   5:{
   6:   int i,n;
   7:   int *arr; // puntero a int
   8:   printf("Ingrese un valor: ");
   9:   scanf("%d",&n);
  10:
  11:   // alocamos n variables enteras con
  12:   // direcciones de memoria consecutivas...
  13:   // es decir: alocamos un array de n enteros
  14:   arr = (int*)malloc(sizeof(int)*n);
  15:
  16:   // asignamos algun valor a cada elemento el array
  17:   for( i=0; i<n; i++ )
  18:   {
  19:      arr[i]=2*(i+1);
  20:   }
  21:
  22:   // mostramos el contenido del array
  23:   for( i=0; i<n; i++ )
  24:   {
  25:      printf("arr[%d] = %d\n",i,arr[i]);
  26:   }
  27:}
  28:

Operaciones Sobre Arrays

Analizaremos las operaciones típicas para manejo de arrays. Simplemente veremos el código de cada función. El .h (en caso que sea necesario) quedará a cargo del lector.


Insertar en un Array

La función insertar insertar un elemento valor en la posición pos del array arr desplazando hacia abajo a los elementos que se encuentran desde pos en adelante.

   1:
   2:// arr   - array sobre el que vamos a insertar
   3:// len   - cantidad de elementos utiles de arr
   4:// valor - valor a insertar
   5:// pos   - posicion (de 0 a len-1) en donde insertar  
   6:
   7:void insertar(int *arr, int *len, int valor, int pos)
   8:{
   9:   int i;
  10:
  11:   for( i=(*len); i>=pos; i-- )
  12:   {
  13:      arr[i]=arr[i-1];
  14:   }
  15:   arr[pos]=valor;
  16:   (*len)++; // incremento el contenido de len
  17:}
  18:
  19:// prueba insertar
  20:int main()
  21:{
  22:   int arr[10];
  23:   int len=0, i;
  24:
  25:   insertar(arr,&len,1,0); // inserta 1 en pos 0
  26:   insertar(arr,&len,2,0); // inserto 2 en pos 0
  27:   insertar(arr,&len,3,0); // inserto 3 en pos 0
  28:
  29:   // el array deberia contener 3,2,1... veremos...
  30:   for( i=0; i<len; i++ )
  31:   {
  32:      printf("%d\n",arr[i]);
  33:   }
  34:}
  35:

Eliminar un elemento del Array

La función eliminar recorre el array con i variando entre pos y la posición del último elemento menos 1. Asigna a arr[i] el elemento de arr[i+1] con lo cual "pisa" el elemento que queríamos eliminar. Por último decrementa el valor de len.

   1:
   2:#include<stdio.h>
   3:
   4:// arr   - array sobre el que vamos a eliminar un elm
   5:// len   - cantidad de elementos utilies de arr
   6:// pos   - posicion del elm que queremos eliminar
   7:
   8:void eliminar(int *arr, int *len, int pos)
   9:{
  10:   int i;
  11:   for( i=pos; i<(*len)-1; i++ )
  12:   {
  13:      arr[i]=arr[i+1];
  14:   }
  15:
  16:   (*len)--;
  17:}
  18:
  19:int main()
  20:{
  21:   // inicializo y dimensiono un array de enteros
  22:   int arr[]={ 1, 2, 3, 4, 5 };
  23:   int len=5;
  24:   int i;
  25:
  26:   // elimino el elemento en la pos 2
  27:   // recordemos que los arrays numeran desde cero
  28:   eliminar(arr,&len,2);
  29:
  30:   // deberia mostrar 1 2 4 5  :O|
  31:   for( i=0; i<len; i++ )
  32:   {
  33:      printf("%d\n",arr[i]);
  34:   }
  35:}
  36:

Buscar un elemento en un Array

La función buscar recorre el array arr mientras no se pase de su longitud len y (obviamente) mientras no se encuentre el elemento valor que se está buscando.

   1:
   2:#include<stdio.h>
   3:
   4:// arr   - array sobre el que vamos a buscar
   5:// len   - elementos utiles del array
   6:// valor - valor que vamos a buscar en arr
   7:
   8:// la funcion retorna la posicion del array donde
   9:// se encontro lo que buscamos o un valor negativo
  10:// si no se encontro
  11:
  12:int buscar(int *arr, int len, int valor)
  13:{
  14:   int i=0;
  15:
  16:   // la condicion logica se evalua de
  17:   // izquierda a derecha, esto nos asegura
  18:   // que i no llegue a ser mayor que len
  19:   while( i<len && arr[i] != valor )
  20:   {
  21:      i++;
  22:   }
  23:
  24:   // el while corta porque i se fue de rango
  25:   // o porque se encontro el elemento. Si este
  26:   // fue el motivo de corte entonces retornamos
  27:   // i ya que el elemento se encontro en arr[i]
  28:   return i>=len?-1: i;
  29:}
  30:
  31:// prueba la funcion buscar
  32:int main()
  33:{
  34:   int arr[]={ 2, 4, 6, 8, 10 };
  35:   int len=5;
  36:
  37:   // deberia imprimir: 2 (se numera desde cero)
  38:   printf("Posicion del 6 = %d\n",buscar(arr,len,10));
  39:   // deberia imprimir: -1 (arr no contiene 5)  
  40:   printf("Posicion del 5 = %d\n",buscar(arr,len,5));
  41:}
  42:

Insertar en Orden un Elemento en un Array

Recorremos el array mientras i no se pase de rango y mientras que arr[i] sea menor que el elemento valor que vamos a insertar. El for corta dejando i con un valor que coincide con la posición en la que debemos insertar valor. Luego invocamos la función insertar para que haga el resto del trabajo.

   1:
   2:#include<stdio.h>
   3:
   4:void insertar(int *arr, int *len, int valor, int pos)
   5:{
   6:   int i;
   7:
   8:   for( i=(*len); i>=pos; i-- )
   9:   {
  10:      arr[i]=arr[i-1];
  11:   }
  12:   arr[pos]=valor;
  13:   (*len)++; // incremento el contenido de len
  14:}
  15:
  16:
  17:// arr   - array en el que vamos a insertar un elm
  18:// len   - cantidad de elementos utiles de arr
  19:// valor - elemento que vamos a insertar (en orden)
  20:
  21:int insertarOrdenado(int *arr, int *len, int valor)
  22:{
  23:   int i=0;
  24:
  25:   // recorro mientras i < len y mientras 
  26:   // el elemento sub i sea menor que el 
  27:   // valor que vamos a insertar
  28:   while( i<(*len) && arr[i]<valor )
  29:   {
  30:      i++;
  31:   }
  32:
  33:   // i apunta a la posicion en la que debemos
  34:   // insertarse el valor
  35:   insertar(arr,len,valor,i);
  36:
  37:   // retornamos la posicion donde se inserto
  38:   return i;
  39:}
  40:
  41:// prueba insertarOrdenado
  42:int main()
  43:{
  44:   int arr[10];
  45:   int len=0;
  46:   int i;
  47:   insertarOrdenado(arr,&len,4);
  48:   insertarOrdenado(arr,&len,3);
  49:   insertarOrdenado(arr,&len,3);
  50:   insertarOrdenado(arr,&len,2);
  51:   insertarOrdenado(arr,&len,1);
  52:
  53:   // deberia imprimir 1 2 3 4
  54:   for( i=0; i<len; i++ )
  55:   {
  56:      printf("%d\n",arr[i]);
  57:   }
  58:}
  59:

Buscar y (si corresponde) Insertar Ordenado

La función busca un elemento valor sobre el array arr. Si lo encuentra asigna 1 al parámetro estaba. Si no lo encuentra entonces lo inserta ordenado, asigna 0 a estaba y retorna la posición del array en la cual se insertó el nuevo elemento.

   1:
   2:#include<stdio.h>
   3:
   4:// definimos los headers de las funciones que vamos
   5:// a utilizar, ya que las estamos desarrollando
   6:// mas abajo. Si no lo hacemos, los posibles errores
   7:// de tipos no se validaran en tiempo de compilacion
   8:int buscar(int*,int,int);
   9:int insertarOrdenado(int*,int*,int);
  10:
  11:// ahora si...
  12:
  13:// arr    - array sobre el que vamos a insertar
  14:// len    - elementos utiles de arr
  15:// valor  - valor que vamos a insertar (ordenado) 
  16://          si es que aun no existia en arr
  17:// estaba - boolean, la funcion asignara true o false 
  18://          si el valor estaba o no
  19:// 
  20:// la funcion retorna la posicion donde se inserto 
  21:// el elemento, si es que se inserto
  22:
  23:int buscarEInsertarOrdenado(int *arr
  24:                          , int *len
  25:                          , int valor
  26:                          , int *estaba)
  27:{
  28:   int ret;
  29:   int i=buscar(arr,*len,valor);
  30:
  31:   if( i<0 )
  32:   {
  33:      ret=insertarOrdenado(arr,len,valor);
  34:      (*estaba)=0;
  35:   }
  36:   else
  37:   {
  38:      ret=i;
  39:      (*estaba)=1;
  40:   }
  41:
  42:   return ret;
  43:}
  44:
  45:// prueba
  46:int main()
  47:{
  48:   // array sobre el que vamos a buscarEInsertar
  49:   int arr[10], len=0;
  50:
  51:   // valores que vamos a insertar en arr
  52:   int toInsert[]={ 4, 3, 5, 2, 3, 4, 1, 6 };
  53:   int lenToInsert=8;
  54:
  55:   // Bob Esponja, pantalones cuadrados
  56:   int valor,i,len=0,pos;
  57:   int estaba;
  58:
  59:   // recorremos el array toInsert invocando a la
  60:   // funcion buscarEInsertarOrdenado pasanadole
  61:   // cada uno de sus elementos y la variable
  62:   // booleana estaba para que le asigne el valor
  63:   // que corresponda
  64:   for( i=0; i<lenToInsert; i++ )
  65:   {
  66:      pos=buscarEInsertarOrdenado(arr
  67:                                 ,&len
  68:                                 ,toInsert[i]
  69:                                 ,&estaba);
  70:
  71:      // vemos por cada valor si ya estaba o no
  72:      // contenido en el array arr
  73:      printf("valor=%d, estaba=%d\n",toInsert[i]
  74:                                    ,estaba);
  75:   }
  76:
  77:   printf("\n");
  78:
  79:   // luego de insertar todos los elementos que 
  80:   // pudimos (descartando los repetidos) del array
  81:   // toInsert en arr, recorremos arr para ver si
  82:   // efectivamente quedo ordenado
  83:   for( i=0; i<len; i++ )
  84:   {
  85:      printf("%d\n",arr[i]);
  86:   }
  87:}
  88:
  89:
  90:int buscar(int *arr, int len, int valor)
  91:{
  92:   int i=0;
  93:   while( i<len && arr[i] != valor )
  94:   {
  95:      i++;
  96:   }
  97:   return i>=len?-1: i;
  98:}
  99:
 100:void insertar(int *arr, int *len, int valor, int pos)
 101:{
 102:   int i;
 103:
 104:   for( i=(*len); i>=pos; i-- )
 105:   {
 106:      arr[i]=arr[i-1];
 107:   }
 108:   arr[pos]=valor;
 109:   (*len)++; // incremento el contenido de len
 110:}
 111:
 112:int insertarOrdenado(int *arr, int *len, int valor)
 113:{
 114:   int i=0;
 115:
 116:   while( i<(*len) && arr[i]<valor )
 117:   {
 118:      i++;
 119:   }
 120:   insertar(arr,len,valor,i);
 121:   return i;
 122:}
 123:

Ordenamiento Burbuja

   1:
   2:#include<stdio.h>
   3:
   4:void ordenar(int *arr, int len)
   5:{
   6:   int ordenado=0;
   7:   int aux,i;
   8:
   9:   while( !ordenado )
  10:   {
  11:      ordenado=1;
  12:      for( i=0; i<len-1; i++ )
  13:      {
  14:         if( arr[i+1]<arr[i] )
  15:         {
  16:            aux=arr[i];
  17:            arr[i]=arr[i+1];
  18:            arr[i+1]=aux;
  19:            ordenado=0;
  20:         }
  21:      }
  22:   }
  23:}
  24:
  25:// prueba la funcion burbuja
  26:int main()
  27:{
  28:   int arr[] = { 4, 3, 6, 1, 2, 7, 9, 8, 5 };
  29:   int i,len=9;
  30:   ordenar(arr,len);
  31:
  32:   // deberia imprimir ordenado....
  33:   for( i=0; i<len; i++ )
  34:   {
  35:      printf("%d\n",arr[i]);
  36:   }
  37:}
  38:

Búsqueda Binaria o Dicotómica

   1:
   2:#include<stdio.h>
   3:
   4:int buscarBin(int *arr, int len, int valor)
   5:{
   6:   int i=0,j=len,k;
   7:   int encontrado=0;
   8:
   9:   while( i<=j && !encontrado )
  10:   {
  11:      k=(i+j)/2;
  12:      if( arr[k]==valor )
  13:      {
  14:         encontrado = 1;
  15:      }
  16:      else
  17:      {
  18:         if( arr[k]<valor )
  19:         {
  20:            i=k+1;
  21:         }
  22:         else
  23:         {
  24:            j=k-1;
  25:         }
  26:      }
  27:   }
  28:   // si i>j retorno -1 sino retorno k
  29:   return i>j?-1:k;
  30:}
  31:
  32:// prueba la busqueda binaria
  33:int main()
  34:{
  35:   // recordemos que la busqueda binaria funciona
  36:   // solo si el array sobre el que vamos a buscar
  37:   // esta ordenado
  38:   int arr[] = { 2, 4, 5, 6, 8, 12, 14, 16 };
  39:   int len=8;
  40:   int aBuscar, res;
  41:
  42:   aBuscar=5;
  43:   res=buscarBin(arr,len,aBuscar);
  44:   // debe imprimir 2 (comienza desde posicion 0)
  45:   printf("Busco: %d, resultado: %d\n",aBuscar, res);
  46:
  47:   aBuscar=9;
  48:   res=buscarBin(arr,len,aBuscar);
  49:   // debe imprimir -1, arr no tiene 9
  50:   printf("Busco: %d, resultado: %d\n",aBuscar, res);
  51:
  52:   aBuscar=16;
  53:   res=buscarBin(arr,len,aBuscar);
  54:   // debe imprimir 7
  55:   printf("Busco: %d, resultado: %d\n",aBuscar, res);
  56:
  57:   aBuscar=2;
  58:   res=buscarBin(arr,len,aBuscar);
  59:   // debe imprimir 0 (primer posicion del array)
  60:   printf("Busco: %d, resultado: %d\n",aBuscar, res);
  61:
  62:   aBuscar=1;
  63:   res=buscarBin(arr,len,aBuscar);
  64:   // debe imprimir -1
  65:   printf("Busco: %d, resultado: %d\n",aBuscar, res);
  66:}
  67:

.