domingo, 20 de marzo de 2016

Estructuras de repetición en JAVA - 1 de 3



Las estructuras de repetición permiten repetir muchas veces un bloque de sentencias. A estas estructuras también se les conoce como estructuras iterativas o bucles.

Como las estructuras de selección, las estructuras de repetición se pueden combinar y anidar. Es frecuente utilizar una estructura de repetición que contenga un bloque de sentencias que combine otras estructuras de repetición y de selección.

Las estructuras de repetición se componen de cuatro partes: la inicialización, la condición, el bloque de sentencias y la actualización.
  • Inicialización. Permite inicializar la estructura iterativa, normalmente consiste en la declaración e inicialización de la variable de control del bucle.
  • Condición. Define la condición que se evalúa para ejecutar el bloque de sentencias de la estructura iterativa. Dependiendo del tipo de estructura que se utilice, la condición se comprueba antes o después de realizar cada iteración.
  • Bloque de sentencias. Conjunto de sentencias que se ejecutan dentro de la estructura iterativa.
  • Actualización. Actualización de la variable de control del bucle. Normalmente se realiza al finalizar la ejecución del bloque de sentencias.


Estructura while

La estructura de repetición while repite el bloque de sentencias mientras la condición del while es verdadera.

El diagrama de flujo de una estructura while muestra que la condición se verifica justo después de inicializar la variable de control. Si el resultado de evaluar la condición por primera es falso, entonces no se ejecuta el bloque de sentencias.




Un while tiene la siguiente sintaxis:

inicialización;
while (condición) {
bloque-de-sentencias;
actualizacion;
}

Esta es la sintaxis general. La condición del while se escribe obligatoriamente entre paréntesis.

Un while no necesariamente requiere inicialización y actualización de una variable de control. En ese caso solo es necesario incluir la condición y el bloque de sentencias:

while (condición) {
bloque-de-sentencias;
}

Cuando el programa ejecuta un while, lo primero que hace es evaluar la condición. Si es verdadera ejecuta el bloque de sentencias, si es falsa finaliza el while.

En cada iteración, cuando finaliza la ejecución del bloque de sentencias se vuelve a evaluar la condición. De nuevo, si es verdadera ejecuta una vez más el bloque de sentencias, si es falsa finaliza el while. Cuando esto se produce, el flujo del programa continúa en la sentencia inmediatamente posterior al while.

Si la primera vez que se evalúa la condición el resultado es falso, entonces no se ejecuta el bloque de sentencias. Por esta razón, se dice que un while se ejecuta cero o más veces. Si la condición siempre es verdadera, entonces el while nunca termina y se ejecuta indefinidamente. Esto se conoce como bucle infinito. 

El siguiente ejemplo muestra el uso del while para calcular la función factorial de un número entero positivo ‘n’.

La función factorial se define:

0! = 1
1! = 1
2! = 1 x 2
3! = 1 x 2 x 3
4! = 1 x 2 x 3 x 4
...
n!= 1 x 2 x 3 x 4 x 5 x ... x (n-2) x (n-1) x (n)

De la definición anterior, se puede calcular el factorial utilizando una estructura repetitiva con una variable de control que empiece en 1 y termine en ‘n’. La actualización de la variable de control del while suma uno cada vez. 

Programa que calcula la función factorial de un número utilizando la estructura while.

public class FactorialWhile {
public static void main(String[] args) {
int n = 5; // n se inicializa a 5 para calcular 5!
int factorial = 1 // factorial se inicializa a 1
int i = 1; // el valor inicial de i es 1
while (i <= n) {
factorial = factorial * i;
i++;
}
System.out.println("El factorial de " + n + " es " +
factorial);
}
}

En la expresión factorial = factorial * i la variable factorial aparece dos veces. Primero se calcula el producto factorial * i y después se asigna este resultado a la variable factorial. Es por esto que la tabla muestra una columna con los valores de los operandos del producto y otra con el valor final de la variable factorial. La siguiente tabla muestra el proceso de cálculo que se realiza en el while.



La variable factorial se inicializa a 1. En la primera iteración i vale 1, se calcula el producto factorial * i con los valores 1 * 1 y se asigna 1 a la variable factorial. En la segunda iteración i vale 2, se calcula factorial * i con los valores 1 * 2 y se asigna 2 a la variable factorial. En la tercera iteración i vale 3, se calcula factorial * i con los valores 2 * 3 y se asigna 6 a la variable factorial. En la cuarta iteración i vale 4, se calcula factorial * i con los valores 6 * 4 y se asigna 24 a la variable factorial. En la última iteración i vale 5, se calcula el producto factorial * i con los valores 24 * 5 y se asigna 120 a la variable factorial. 

De los resultados de la tabla anterior, se puede observar que no es necesario calcular el producto factorial * i en la primera iteración cuando i vale 1. Este producto siempre va a dar como resultado 1.

El algoritmo es más eficiente si se elimina la primera iteración, basta con inicializar la variable de control i a 2. En este ejemplo, el valor inicial de i es 1 para que el algoritmo sea más claro.


Espero haber ayudado en algo. Hasta la próxima oportunidad!











  

No hay comentarios:

Publicar un comentario en la entrada