Estructuras de Control: Iteraciones
| ||||||||||||||
Una de las características importantes que se pueden aprovechar de las computadoras es precisamente su capacidad de repetir la ejecución de secuencias de instrucciones a una gran velocidad y con alto grado de confiabilidad. Para estos fines, precisamente se definen en los lenguajes de programación las estructuras de control iterativas. El objetivo de estas estructuras es permitir la expresión de la repetición de una secuencia de instrucciones, a estas estructuras se les denomina ciclo, lazo o bucle.
Sumario
Estructuras de Control Iterativas
En la vida diaria existen situaciones que frecuentemente se resuelven realizando una determinada secuencia de pasos que puede repetirse muchas veces, ejemplo:
- El proceso que seguimos para comer, mientras no se termine la comida.
- El proceso de insertar monedas, hasta que se abone la cantidad necesaria.
- Las operaciones que realizamos para llamar por teléfono, mientras no se logre la comunicación.
Como se puede observar estos son algoritmos que se hacen cotidianamente, pero tienen la particularidad de que la ejecución de alguno de sus pasos puede repetirse muchas veces, mientras no se logre la meta trazada. A este tipo de algoritmo se le conoce como algoritmos iterativos o repetitivos. En C#, las instrucciones while, do/while, y for, permiten ejecutar iteraciones, bucles o ciclos. En cada caso se ejecuta un bloque de instrucciones mientras la condición que se evalúa tome valor verdadero. Se resalta que cualquiera de las 3 instrucciones cumple con el mismo objetivo que es el de ejecutar una secuencia de pasos, más de una vez.
La instrucción while
La instrucción while tiene la siguiente sintaxis:
La semántica de la instrucción es la siguiente:
- <condición>. Está representada por una expresión booleana y mientras se cumpla se ejecutará el ciclo.
- [Bloque de Instrucciones] El bloque de instrucciones puede estar formado por una o varias instrucciones y es el conjunto de pasos que se van ejecutar en cada iteración del ciclo.
Para una mayor comprensión se muestra su representación en un diagrama de actividad.
Esta estructura de control permite repetir o iterar el [Bloque de Instrucciones] mientras la condición sea verdadera o dicho de otra manera, estas iteraciones terminarán cuando la condición sea falsa y entonces se podrá ejecutar la siguiente instrucción después del while.
Es válido señalar que en esta instrucción la condición se evalúa al inicio del ciclo por lo que si la primera vez que se evalúa la condición esta es falsa, el ciclo no llegará a realizarse.
La instrucción do/while
La estructura de control do/while es otra sentencia de iteración en la que la condición se evalúa por primera vez una vez que se haya ejecutado el [Bloque de Instrucciones] y tienen la siguiente sintaxis:
Su semántica es la misma que la de la instrucción while y su representación en un diagrama de actividad es la siguiente:
En esta estructura repetitiva el bloque de instrucciones siempre se ejecuta al menos una vez pues la condición se evalúa al final. Una vez realizada la evaluación si el resultado es true, se vuelve a ejecutar el [Bloque de Instrucciones], en caso contrario se ejecutan las instrucciones que sigan a continuación saliendo del ciclo. La funcionalidad de este método será la misma que en el ejemplo con while. La única diferencia es la forma en que se controla el bucle. En la práctica, verá que la instrucción while se utiliza más a menudo que la instrucción do – while. El elegir una instrucción en lugar de la otra es una elección personal. Un aspecto muy importante a tener presente en los ciclos condicionales es la necesidad de contemplar dentro del bloque de instrucciones al menos una, que de alguna manera, altere –en algún momento- el resultado de la expresión booleana. La explicación sencillamente está dada por el hecho que de no existir esta instrucción una vez entrada al ciclo este nunca terminaría por lo que se caería en un ciclo infinito.
La estructura de control for
Los procesos iterativos que se han visto hasta ahora terminan por una condición. En muchas situaciones las iteraciones se realizan un número determinado de veces, muchos autores les llaman ciclos por conteo pues se conoce de antemano cuántas veces se hará el proceso que se repite. En este tipo de iteración, siempre se necesita una variable que lleve el control de las veces que se repite el proceso por esto se les conoce también como ciclos con variable de control. Uno de los ciclos más conocidos y usados en la mayoría de los lenguajes de programación es el de la instrucción for que suele estar controlado por un contador o variable de control y tiene la siguiente sintaxis:
La semántica de la instrucción es la siguiente:
- <instrucciones 1>. Se ejecutará una sola vez al inicio del ciclo, generalmente se realizan inicializaciones y declaraciones de variables puesto que como se dijo con anterioridad, esta solo se ejecuta una vez. En caso de que se quiera realizar o ejecutar más de una instrucción en este momento, dichas instrucciones se deben separar por comas (“,”).
- <expresión>. Es evaluada en cada iteración y en dependencia del valor que devuelva, dependerá que el ciclo continúe ejecutándose (valor de la expresión true) o no (false). Destacar que de no colocarse nada en esta parte, el ciclo tomará como true el valor de la expresión por lo que en principio, el ciclo puede estar repitiéndose infinitamente.
- <instrucciones 2>. Es ejecutado siempre en cada ciclo al terminar de ejecutar todas las instrucciones que pertenecen al bucle for en cuestión. Por lo general puede contener alguna actualización para las variables de control. Análogamente a <instrucciones 1> en caso de querer ejecutar en este momento más de una instrucción se deben separar por comas.
Observe que es obligatorio para separar cada término que compone la instrucción for utilizar un punto y coma (;) de lo contrario el compilador mostrará un error de tipo semántico. Reiterar que la <instrucción 1> se ejecuta una sola vez al comienzo, que la <instrucción 2> es la que generalmente se utiliza para modificar la variable de control aunque en el ciclo esta puede modificarse también, y que <expresión>, es la que garantiza la finitud del ciclo, el for se estará ejecutando siempre y cuando <expresión> sea evaluada y tome valor true.
Caso de Estudio
Para mejor entendimiento de lo expuesto anteriormente, se presenta el siguiente caso de estudio en que se trabajará con cada una de las estructuras repetitivas.
MCD()
Para implementar la responsabilidad de la clase de calcular el Máximo Común Divisor MCD se utilizará el algoritmo de Euclides que consiste en:
- P1: Si los números son iguales, tomar el primer número como respuesta y concluir la ejecución del algoritmo, en otro caso pasar al paso 2.
- P2: Determinar cuál de los dos números es mayor.
- P3: Sustituir el número mayor por la diferencia entre los números mayor y menor.
- P4: Pasar al paso 1.
Obsérvese como se repiten los pasos 1,2 y 3 y el paso 4 consiste precisamente en regresar al paso 1, esta repetición se conoce normalmente con el nombre de iteración, nótese que esta no es infinita, precisamente en el primer paso se especifica que los pasos siguientes (2, 3, 4) han de ejecutarse si no cumple la condición de que los números sean iguales. Esta condición es una expresión booleana.
- Ejecutar el algoritmo para un par de valores (8 y 20 por ejemplo)
Para implementar el método que permita calcular el máximo común divisor utilizaremos la estructura de control while se evaluará la condición de que los números sean diferentes y en dependencia del resultado de la misma se ejecutarán o no los pasos que forman parte del ciclo. El método MCD, quedaría de la siguiente manera:
CantDigitos()
Para determinar la cantidad de dígitos que tiene el número, primeramente se divide el número entre 10, si el cociente de la división es 0, se toma 1 como respuesta, sino, se toma dicho cociente y se divide entre 10, este proceso se estará repitiendo mientras el nuevo cociente sea distinto de 0. Como se observa, al menos se necesita realizar una división, por lo que la estructura do/while es la indicada para implementar este algoritmo. Para implementar el método hay que tener en cuenta lo siguiente:
- P1: Se realiza la división del número entre 10.
- P2: Se almacena el cociente en una variable y se cuenta que número de división es.
- P3: Si el resultado del cociente es distinto de 0, se repite el paso 1.
El método quedaría de la siguiente manera:
Factorial()
Para implementar la última responsabilidad propuesta, Calcular el Factorial, utilizaremos la estructura de control for, ya que se conoce de antemano la cantidad de operaciones (multiplicaciones) que hay que realizar. Recuerde que el factorial de un número es el resultado de la multiplicación desde 1 hasta el número en cuestión.
- Ejemplo: Factorial de 5 es: 1 * 2 * 3 * 4 * 5 = 120
El método quedaría de la siguiente manera.
Ciclos Anidados
En muchos casos de la vida diaria no basta con repetir un grupo de instrucciones una cantidad de veces sino que esas repeticiones deben ser realizadas al mismo tiempo un número de ocasiones. Este tipo de problemas da origen a los algoritmos con ciclos compuestos o ciclos anidados. Los ciclos anidados o compuestos no son más que ciclos que tienen otros ciclos dentro del bloque de instrucciones que deben ejecutar. Esta facilidad de componer uno o más ciclos en combinación con algunas estructuras de almacenamiento resulta muy útil para la solución de algunos algoritmos de búsqueda y ordenación que se verán más adelante en el curso. Usualmente los ciclos que se componen para resolver un algoritmo en particular son los ciclos por variable de control, lo que no quiere decir que no se pueda hacer con ciclos con condición o con una combinación de ellos dos, lo que resultan menos frecuentes estos casos.
Fuentes
- Grady Boosh. Análisis y Diseño Orientado a Objetos con Aplicaciones
- Bertran Meyer. Touch of Class
- M. Katrib, E. Quesada; Programación con Pascal, Pueblo y Educación, 1991.
- Colectivo de autores. Programación Orientada a Objetos con C#
