Arreglos de una dimensión (vectores).

   Los arreglos de una dimensión se denominan comúnmente arreglos o vectores, en este texto se utilizará la primera denominación.

Conceptos, representación y estructura.

   Los arreglos son una estructura de datos lineal de elementos contigüos relacionados por un mismo tipo de datos, un mismo nombre (identificador), y distinguidos por un índice.

(a) Representación de un arreglo (Abstracción).

 

 

(b) Representación de un arreglo en la memoria.

   Las figuras anteriores muestran la representación de un arreglo de tamaño cuatro de nombre arreglo. En (a) se observa la representación abstracta de dicho arreglo, mientras que en (b) se presenta la forma en que dicho arreglo es almacenado en la memoria principal de la computadora. Note que los arreglos se representan de forma lineal directa en la memoria de la computadora.

   Los arreglos en C siempre empiezan en el índice 0 y terminan en tamaño - 1, dónde tamaño se refiere al tamaño, dimensión o longitud del arreglo.

   Un aspecto importante a considerar respecto a la conveniencia en el uso de arreglos es la siguiente: no es lo mismo declarar 100 variables de tipo entero que un arreglo de 100 enteros ¿Puede imaginar lo terriblemente tedioso que sería declarar 100 variables de tipo entero?

   Otra ventaja de utilizar arreglos en lugar de una tediosa declaración masiva de variables, es que el grupo de datos relacionados por el nombre del arreglo están contigüos en la memoria, mientras que no necesariamente sería así para el grupo de variables declaradas individualmente.

   En general, la declaración de un arreglo en el lenguaje de programación C tiene la siguiente estructura general:

tipo_de_dato   nombre_del_arreglo[TAMAÑO];

en donde:

• tipo_de_dato es cualquier tipo de dato válido en C.
• nombre_del_arreglo es un identificador válido en C.
• TAMAÑO es la longitud o tamaño que tendrá el arreglo.

Declaración, inicialización y recorrido.

   El Ejemplo 6.1 muestra la declaración, inicialización y recorrido de un arreglo de enteros.

   En la línea 10 se está declarando un arreglo de nombre arreglo de tamaño N. Observe que el arreglo está siendo inicializado en la declaración o en tiempo de compilación; lo que hace el compilador es asignarle 0 al elemento arreglo[0] y 1 al elemento arreglo[1], todos los demás elementos del arreglo se inicializan por omisión en 0, es decir:

arreglo[ 0 ] = 0
arreglo[ 1 ] = 1
arreglo[ 2 ] = 0
arreglo[ 3 ] = 0 
. . . 

arreglo[N-1] = 0

   Si un arreglo, independientemente de su tipo de dato, se declara pero no se inicializa, el contenido de cada unos de sus elementos no está determinado a un valor concreto o específico, lo cual implica que contendrán lo que en el argot computacional se conoce como basura.

   La línea 13 está realizando un recorrido del arreglo; note que para dicho recorrido, el índice se inicializa en 2, mostrando así que es posible iniciar el recorrido de un arreglo en donde se necesite, y no siempre desde 0.

   Por otro lado, la línea 14 está asignándole valores al arreglo a partir de la posición 2. Observe que el valor i-ésimo del arreglo se define como la suma de los dos valores anteriores, por lo que en realidad lo que hace el ciclo for es inicializar el arreglo con los valores de la serie de Fibonacci que se estudió en la entrada referente a la recursividad.

   Finalmente, las líneas 18 y 19 son lo que se conoce como un recorrido para impresión del arreglo, en el cual se imprime por renglón en la salida estándar, cada uno de los elementos del arreglo arreglo. La salida del Ejemplo 6.1 se  muestra en la siguiente figura:

Salida del Ejemplo 6.1.

 

    Ahora bien, el Ejemplo 6.2 muestra otra variante de inicialización de arreglos y un doble recorrido para un arreglo de tipo float.

   Observe que el arreglo a de la línea 10 no tiene un tamaño explícito. Cuando se declara un arreglo en C, éste debe tener una dimensión o tamaño definidos explícita o implícitamente; para el caso del Ejemplo 6.2 el tamaño está implícito, y es determinado por el número de inicializadores (5), los cuales son calculados por el compilador y no están relacionados con el #define de la línea 7, al menos en cuanto a la definición del tamaño del arreglo se refiere.

   La estructura de repetición for de la línea 15, utiliza dos variables de control para hacer un recorrido ascendente (i) y descendente (j) del arreglo a, con la finalidad de mostrar que no siempre ni necesariamente los arreglos se recorren de manera ascendente. La salida del Ejemplo 6.2 muestra en la siguiente figura:

Salida del Ejemplo 6.2.

Arreglos.

   Antes de iniciar con los conceptos y la descripción de los arreglos, considere el siguiente problema:

Se desea almacenar un grupo de cuatro calificaciones, y determinar:

• Cuál es la menor.
• Cuál es la mayor.
• Cuáles y cuántas son aprobatorias y reprobatorias en base a un determinado criterio.
• Su media aritmética (promedio).
• Si existe o no una calificación específica.

Finalmente, las calificaciones deben ser ordenadas de manera ascendente.

   Con lo que se ha presentado hasta ahora en las entradas anteriores, ¿puede dar solución a este problema?, y si en lugar de cuatro calificaciones se tuvieran que procesar diez, ¿qué cambios tendría que hacer?, ¿y si en lugar de diez fueran 100?, ¿y si fueran 1000 o más?

   La situación presentada con anterioridad se puede resolver sin importar el número de calificaciones; el "problema" es que por cada nuevo incremento en el número de calificaciones tendrían que agregarse nuevas variables con sus respectivos identificadores, además de modificar el código que realiza las tareas solicitadas (lectura de datos, procesamiento, etcétera) para considerar a estas nuevas variables. Dicha labor, además de tediosa es ardua, pero sobre todo, ineficiente.

   Con base en lo anterior, debería ser claro que se requiere de algo más, se necesita otra cosa, algo que permita manejar mejor y de manera general este tipo de problemas. Pues bien, eso que hace falta es lo que se conoce como arreglos.

   Un arreglo es una estructura de datos con un tamaño determinado que agrupa elementos del mismo tipo de datos, los cuales están relacionados por un nombre (identificador) y se distinguen por uno o más índices.

   En entradas subsecuentes se analizarán los arreglos de una dimensión, también conocidos como vectores, los arreglos de dos dimensiones o matrices, los arreglos de tres dimensiones, y una generalización para los arreglos de n dimensiones.

Torres de Hanoi.

   Existen varias versiones y variantes del problema de las torres de Hanoi, pero la versión clásica y más común es la siguiente:

Se tienen tres postes, normalmente denotados como A, B y C, y en uno de ellos (poste de origen, usualmente A) se tienen apilados n discos de diferentes diámetros. 

El problema consiste en pasar los n discos del poste origen al poste destino (usualmente C) manteniendo en todo momento las siguientes reglas:

1. Sólo se puede mover un disco cada vez.
2. Un disco de mayor diámetro no puede estar sobre uno de menor diámetro.
3. Sólo se puede mover el disco que se encuentre en la parte superior de cada poste.

   Ahora bien, para el caso de n = 1, si A es el poste origen, C el poste destino, y B el poste auxiliar, la solución es directa:

Mover el disco 1 del poste A al poste C.

   Para el caso de n = 2, si A es el poste origen, C el poste destino, y B el poste auxiliar, la solución está dada por los siguientes movimientos de discos, donde el disco 1 es el más pequeño y el disco 2 es el más grande:

Mover el disco 1 del poste A al poste B

Mover el disco 2 del poste A al poste C

Mover el disco 1 del poste B al poste C

   Para el caso de n = 3, si A es el poste origen, C el poste destino, y B el poste auxiliar, la solución está dada por los siguientes movimientos de discos, donde el disco 1 es el más pequeño y el disco 3 es el más grande:

Mover el disco 1 del poste A al poste C

Mover el disco 2 del poste A al poste B

Mover el disco 1 del poste C al poste B

Mover el disco 3 del poste A al poste C

Mover el disco 1 del poste B al poste A

Mover el disco 2 del poste B al poste C

Mover el disco 1 del poste A al poste C

   Para visualizar mejor la solución, se sugiere como ejercicio realizar los dibujos que reflejen la naturaleza de estos movimientos. Adicionalmente, se sugiere realizar la misma labor para cuatro y cinco discos. Hágalo antes de continuar.

   Si realizó lo sugerido en el párrafo anterior, quizá haya identificado algunos patrones:

• Para el caso de cuatro discos, se tiene la situación inicial sugerida por la siguiente figura:

• Para el caso de cuatro discos (en general para el caso de n discos), después de algunos movimientos se tiene la situación presentada en la siguiente figura, en la que se observan los n - 1 discos colocados en la posición auxiliar B, y el disco de mayor diámetro listo para ser movido a su posición final:

• El siguiente paso es el movimiento del disco de mayor diámetro de la posición origen A hacia su posición final de destino (C). Observe que los discos en la posición auxiliar no se afectan, como lo muestra la siguiente figura:

• Ahora bien, de la figura anterior puede notarse lo siguiente: en la posición B están los n - 1 discos restantes, es decir, el problema original de n discos pero simplificado (al menos por un disco), por lo que, si se toma como nuevo origen la posición B, se mantiene el destino en la posición C y se hace que la posición auxiliar sea ahora A, se tiene la misma situación del problema original pero con menos discos y con nuevos roles respecto a la posición de origen y la auxiliar.

   En resumen el problema se reduce ahora a mover los n - 1 discos de la posición B a la posición C utilizando a la posición A como auxiliar, y si se repite el procedimiento, se obtendrá eventualmente la situación presentada en la siguiente figura:

   De lo anterior se pueden deducir las relaciones de recurrencia y el caso base para dar solución recursivamente al problema de las torres de Hanoi. De manera general, se presenta a continuación el algoritmo de las torres de Hanoi:

Algoritmo mover_disco(n: entero, origen: character, destino: character, auxiliar: character)
Inicio
            if (n == 1)
                        imprimir mover el disco n de la posición origen a la posición destino
            else
                        mover_disco(n - 1, origen, auxiliar, destino)
                        imprimir mover el disco n de la posición origen a la posición destino
                        mover_disco(n - 1, auxiliar, destino, origen)
            end if
Fin

   Observe que el algoritmo anterior es una descripción en pseudo código de los patrones identificados en el texto. Por otro lado, si se realizó el ejercicio sugerido con anterioridad, un análisis cuidadoso deberá llevar al lector a la identificación de dichos patrones.

Consideraciones adicionales.

   En resumen, las implementaciones recursivas son en general ineficientes en tiempo y espacio, pero muy elegantes y simples una vez que se tiene identificada la relación de recurrencia. En este sentido, siempre que pueda identificar un enfoque iterativo que sea sencillo de implementar, opte por él.

   Por otro lado, el problema de las torres de Hanoi es un ejemplo ineludible de que por medio de la recursividad es posible solucionar problemas complejos de manera bastante sencilla, aunque el precio a pagar sea la eficiencia en tiempo y espacio de memoria. Intente resolver el problema de las torres de Hanoi de manera iterativa para tener una mejor comprensión de lo anterior, y experimente directamente y de primera mano el eterno conflicto (tradeoff) computacional entre espacio vs. tiempo, y eficiencia vs. simplicidad.

Ejercicios selectos (recursividad).

1. En la entrada Recursividad (Definición y conceptos), se presenta y describe brevemente una figura geométrica generada mediante un proceso recursivo potencialmente infinito. Siguiendo lo descrito en dicha entrada, dibuje en papel la figura geométrica correspondiente de Nivel 5.
2. Haga un análisis de los llamados y retornos recursivos como los realizados en la entrada "Soluciones iterativas vs. recursivas" para los llamados de función factorial(5) y factorial(6).
3. Escriba un programa que, a través de una función recursiva, calcule el producto de dos números enteros positivos a y b por medio de sumas sucesivas, esto es: a * b = a + a + . . . + a, donde a se suma tantas veces como lo indique b.
4. Realice en una hoja de papel el árbol de recursividad que se genera para el cálculo de fibonacci(5) y fibonacci(6) como el que  se mostró en "Soluciones iterativas vs. recursivas".
5. Escriba un programa que, a través de una función recursiva, calcule el cociente entero de dos números enteros positivos a y b por medio de restas sucesivas, esto es a / b ==>
1.   a - b = c1, si c1 >= b, entonces
2. c1 - b = c2, si c2 >= b, entonces
3. c2 - b = c3, si c3 >= b, entonces
4.         .     .     .                                         donde el cociente estará dado por el número de veces que se haya podido repetir el procedimiento descrito.
6. Escriba un programa que, a través de una función recursiva, calcule la potencia de dos números enteros positivos a y b por medio de productos sucesivos, esto es: a^b = a * a * .  .  . * a, donde a se multiplica tantas veces como lo indique b.
7. Compare las versiones recursivas con las versiones iterativas descritas en el blog y analícelas. Simplemente por la lectura del código, ¿qué versión representa una mejor abstracción de las definiciones matemáticas? Realice diferentes ejecuciones y determine qué versión tiene un mejor rendimiento.
8. Tanto el factorial como la serie de Fibonacci crecen de manera exponencial y no hay tipo de dato que las pueda contener. En el lenguaje de programación C, los tipos de datos numéricos dividen su rango tanto en números positivos como en números negativos, por lo que su capacidad de almacenamiento se ve, por decirlo de alguna manera, dividida. Sin embargo, existe el modificador unsigned (sin signo), que instruye al compilador para usar todo el rango de bits del tipo de dato para representar números positivos incluyendo el cero. Pruebe con este modificador de tipo de datos, documéntese en su funcionamiento y su especificador de formato, y amplíe la capacidad de representación para los resultados de los ejemplos estudiados en el blog.
9. En base a lo indicado en el ejercicio anterior, calcule con la versión iterativa y recursiva respectivamente, fibonacci(52), ¿qué observa? ¿qué puede deducir?
10. En base a lo expuesto en el blog y basándose en el Ejemplo 5.5, determine el tiempo en segundos que tarda la función de Fibonacci en determinar, por ejemplo, fibonacci(49) en sus respectivas versiones: iterativa y recursiva.
11. Escriba un programa que, en base al algoritmo descrito para las Torres de Hanoi, resuelva dicho problema por medio de una función recursiva. Note que es un proceso de simple traducción al lenguaje C, ya que tanto las relaciones de recurrencia, como el criterio de paro están dados en el algoritmo.
12. Basándose en el ejercicio anterior y en el Ejemplo 5.5, determine el tiempo en segundos que tarda la función que da solución al problema de las torres de Hanoi para 20, 35 y 50 discos por ejemplo.