UNIVERSIDAD DE ORIENTE

NÚCLEO DE MONAGAS

ESCUELA DE INGENIERIA Y CIENCIAS APLICADAS

CURSO ESPECIAL DE GRADO

Programacion Iterativa

Profesora: Ing. Jhonatan Vasquez

Maturín, Abril del 2015

Bachilleres:Centeno G. Renny J. C.I. 21.350.253Fernández G. Ana B. C.I. 21.329.313

Contenido1. Introducción...................................................................................................................3

2. Marco teórico.....................................................................................................................4

2.1 Programación...............................................................................................................4

2.2 Iteración.......................................................................................................................4

2.3Iteración en la programación......................................................................................4

2.4 Iteración declarativa...................................................................................................4

2.4.1 Bucle While............................................................................................................5

2.4.2 Bucle For................................................................................................................5

2.4.3 Bucle do while.......................................................................................................5

2.4.4 Sentencias Break, Continue y Return.................................................................6

2.5 Iteración con funciones recursivas.............................................................................7

2.6 Diferencias entre métodos recursivos y métodos iterativos.....................................8

3. Discusión............................................................................................................................9

4.Conclusion.........................................................................................................................11

5. Bibliografía......................................................................................................................12

1. Introducción

La programación es un mundo amplio con muchas posibilidades, no todo es pulir una brillante idea y sentarse al frente de un editor de texto o un entorno de desarrollo de confianza, para programar es necesario conocer en un amplio aspecto las diferentes técnicas y herramienta que nos permitirán resolver problemáticas que se nos puedan ir presentando mientras desarrollemos esa idea.

Al igual que en la vida que se nos pueden presentar ciertos escenarios y la manera de solucionarlos cambia dependiendo de cada uno, de igual forma sucede en la programación, existe una técnica o practica común que se utiliza para atacar un tipo de problema en específico, una de esas técnicas que nos sacaran las castañas del fuego en más de una ocasión es la iteración, la iteración no es una palabra desconocida de seguro más de una vez la hemos escuchado, y es que no es más que repetir un proceso un número determinado de veces hasta cumplir con una condición.

Conociendo bien que significa iterar no es difícil trasladar ese conocimiento hacia nuestros proyectos que desarrollaremos en un lenguaje de programación determinado, es fácil imaginarse una situación donde se deba repetir una acción tantas veces sea necesario hasta obtener el resultado que se espera, por ejemplo si se desea que el usuario ingrese un código especifico y se diseñe el código de tal forma que hasta que no ingrese ese código no se pueda seguir avanzando en la aplicación, como ese ejemplo existen muchísimos más donde resulta muy útil y casi que indispensable utilizar las iteraciones.

Existen 2 formas de ejecutar iteraciones en una aplicación, la primera es mediante bucles donde a través de variables y estructuras comunes de control se especifica el código para que se cumplan los ciclos necesarios antes de salir de ese código, la manera de realizar esos bucles varia de lenguaje en lenguaje pero la esencia es la misma, ejemplos de estos bucles son el while,for, do while entre otros.

Otra forma de aplicar las iteraciones es mediante funciones recursivas, estas tienen la característica especial que se llaman así mismas para realizar su labor iterativa y también cuenta con el apoyo de las estructuras de control, ambas técnicas son importantes y cuentan con sus pro y contras, todo buen programador debe conocerlas bien si quiere estar bien calificado a la hora de programar.

2. Marco teórico

2.1 Programación

La programación informática, acortada como programación, es el proceso de diseñar, codificar, depurar y mantener el código fuente de programas computacionales. El código fuente es escrito en un lenguaje de programación. El propósito de la programación es crear programas que exhiban un comportamiento deseado. El proceso de escribir código requiere frecuentemente conocimientos en varias áreas distintas, además del dominio del lenguaje a utilizar, algoritmos especializados y lógica formal. Programar no involucra necesariamente otras tareas tales como el análisis y diseño de la aplicación (pero sí el diseño del código), aunque sí suelen estar fusionadas en el desarrollo de pequeñas aplicaciones.

Del proceso de programación surge lo que comúnmente se conoce como software (conjunto de programas), aunque estrictamente este último abarca mucho más que sólo la programación.

2.2 Iteración

Iteración significa el acto de repetir un proceso con el objetivo de alcanzar una meta deseada, objetivo o resultado. Cada repetición del proceso también se le denomina una "iteración", y los resultados de una iteración se utilizan como punto de partida para la siguiente iteración.

2.3Iteración en la programación

En programación, Iteración es la repetición de un proceso dentro de un programa de computadora. Puede usarse tanto como un término genérico (como sinónimo de repetición) así como para describir una forma específica de repetición con un estado mutable.

Cuando se usa en el primer sentido, la recursividad es un ejemplo de iteración, pero que usa su propia notación (notación recursiva), que no es el caso de iteración.

Sin embargo, cuando se usa en el segundo sentido (caso más restringido), la iteración describe el estilo de programación usado en lenguajes de programación imperativa. Esto está en contraposición de la recursividad, la cual tiene un enfoque más declarativo.

2.4 Iteración declarativa

Los bucles se utilizan para ejecutar un conjunto de instrucciones varias veces basándose siempre en una condición que decidirá si se sigue repitiendo o no. Veamos los tipos que hay, a modo de ejemplo nos basaremos en el lenguaje java. 

2.4.1 Bucle While 

while (expresion) {sentencias} 

Las instrucciones dentro de las llaves se ejecutan mientras la expresión sea verdadera. 

i=5;

while ( i > 0 ) {i --;}

// las llaves aquí se podían haber omitido, puesto

// que solo hay una sentencia.

System.out.println("Ahora i vale 0");

2.4.2 Bucle For 

Es un bucle más "fijo", permite ejecutar el conjunto de sentencias un número determinado de veces fijado al principio del bucle y funciona por tanto como un contador. Su expresión general seria como la que sigue: 

for (inicialización, expresionBooleana, incremento) {conjuntoDeSentencias;} 

for (int i= 0; i <10; i++) {     System.out.println("el valor de i es: " + i); }

Este ejemplo nos mostraría por la pantalla diez líneas diciéndonos el valor creciente de 'i' de cero a nueve.

2.4.3 Bucle do while 

Es igual al bucle while anteriormente visto, solo que ahora se evalúa la expresión al final del bucle, por lo que ese conjunto de sentencias se ejecuta al menos una vez: 

i=5; do {i --;} // las llaves aquí se pueden omitir puesto while ( i > 0 ) // que solo hay una sentencia.

Este ejemplo similar al anterior para el bucle while se diferencia en que ejecuta una vez más las sentencias en su cuerpo puesto que comprueba la condición posteriormente. 

2.4.4 Sentencias Break, Continue y Return 

Antes hemos hablado de la sentencia Break con las bifurcaciones switch. Pues bien, esta sentencia tiene un valor más amplio. La sentencia break nos permite salirnos del bloque de sentencias (encerrado entre llaves) o el bucle que estamos ejecutando, sin ejecutar las sentencias que resten para el final o las restantes iteraciones del bucle. Por ejemplo:

i=5;

do{

i --;

if (i == 3) break;

} while ( i > 0 )

// En este ejemplo cuando i tenga el valor 3

// se abandonará el bucle.

La sentencia Continue solo es válida para bucles, sirve para no ejecutar las sentencias que restan para la finalización de una iteración de ese bucle, continuando después con las siguientes iteraciones del bucle. Por ejemplo: 

i=5;

do{

if (i == 3) continue; i --;

}while ( i > 0 ) // En este ejemplo cuando i tenga el valor 3

// se abandonará la iteración y por tanto el

// bucle no tendrá fin puesto que no se

// ejecutaría la sentencia de decremento.

Tanto la sentencia continue como break se pueden utilizar con etiquetas para poder discriminar los bucles que quieren afectar en caso de que se encuentren en un bucle anidado. Por ejemplo: 

Bucle1:

for (int i=0; i<10; i++){

bucle2:

for (int j=0; i<10; j++){

if (j==5) {break bucle2;}

}

} // cuando j llega a 5 el bucle2 deja de

// ejecutarse hasta la siguiente iteracion

// del bloque1

Por último vemos la sentencia return. Esta sentencia nos permite finalizar también un conjunto de sentencias, con la peculiaridad esta vez de que también finaliza el método o función que en el que se encuentre. En el caso de que queramos devolver un valor desde esa función o método lo debemos poner a continuación de return. Por ejemplo: 

void funcionEjemplo(){

int i=0;

while (i < 100){ //esta absurda función nos devuelve

i++; //al llamarla el valor 100 como has

} //podido comprobar

return i;

}

2.5 Iteración con funciones recursivas

Como definición general, podemos decir que una función recursiva es aquella que se llama a sí misma para resolverse. Dicho de otra manera, una función recursiva se resuelve con una llamada a sí misma, cambiando el valor de un parámetro en la llamada a la función. A través de las sucesivas llamadas recursivas a la función se van obteniendo valores que, computados, sirven para obtener el valor de la función llamada originalmente.

El proceso de llamadas recursivas siempre tiene que acabar en una llamada a la función que se resuelve de manera directa, sin necesidad de invocar de nuevo la función. Esto será siempre necesario, para que llegue un momento que se corten las llamadas reiterativas a la función y no se entre en un bucle infinito de invocaciones.

Quizás en la teoría cueste más ver lo que es una función recursiva que por la práctica. Un ejemplo típico de recursividad sería la función factorial. El factorial es una función matemática que se resuelve multiplicando ese número por todos los números naturales que hay entre él y 1.

Por ejemplo, factorial de 4 es igual a 4 * 3 * 2 * 1. Si nos fijamos, para el ejemplo de factorial de 4 (factorial se expresa matemáticamente con un signo de admiración hacia abajo, como 4!), se puede resolver como 4 * 3! (4 * factorial de 3). Es decir, podemos calcular el factorial de un número multiplicando ese número por factorial de ese número menos 1.

n! = n * (n-1)!

En el caso de la función factorial, tenemos el caso básico que factorial de 1 es igual a 1. Así que lo podremos utilizar como punto de ruptura de las llamadas recursivas.

Así pues, vamos a realizar la codificación de la función recursiva factorial. Primero veamos un pseudocódigo:

funcion factorial(n)

si n=1 entonces

factorial = 1

sino

factorial = n * factorial(n-1)

fin función

Ahora veamos cómo se implementaría esta función con el lenguaje de programación Javascript:

function factorial(n){   if(n==1)      return 1   else      return n * factorial(n-1)}

Como se puede ver, la recursividad no representa ninguna dificultad y de hecho es una herramienta muy útil para programación de algoritmos. 

Hay muchos algoritmos que sólo se resuelven con recursividad, o al menos cuya resolución más directa y elegante está basada en realizar funciones recursivas, que se llamen a sí mismas para obtener el resultado final. Por ejemplo el recorrido de diversas estructuras de datos, como las de tipo árbol, siempre se acostumbran a realizar de manera recursiva, para poder estar seguros de que pasamos por todas las ramas del árbol.

2.6 Diferencias entre métodos recursivos y métodos iterativos

Recursivos Iterativos

Se llaman así mismos Utilizan bucles

Ocupan memoria considerable Requieren poco espacio de memoria

Moderadamente complejos Fáciles de construir

Resuelve los problemas de manera elegante Son poco elegantes pero eficientes

3. Discusión

Como todos sabemos la programación nos va a permitir realizar cosas maravillosas mediante líneas de código que le transmitimos a una máquina, con diversas técnicas logramos que estas líneas de códigos contengan ciertas características que satisfagan cualquier problemática que se deba tratar en el programa en cuestión, una de las técnicas que se deben conocer son los métodos iterativos, en sus dos facetas, funciones recursivas y bucles iterativos, ambos nos permitirán realizar tareas donde se requiere iterar un proceso una cantidad de veces necesaria para satisfacer una condición.

Iterar significa repetir un proceso hasta obtener el resultado esperado, estas repeticiones se les conoce como iteraciones, mientras más iteraciones se tenga por supuesto más largo o complejo será el código iterativo, esto en el caso de usar un método iterativo de manera de bucle, donde partiendo de ciertas condiciones se dispone a realizar las diferentes iteraciones hasta llegar a la condición de parada, existen diversos bucles para afrontar diferentes situaciones que requieran del uso de iteraciones, de igual manera dependiendo del lenguaje varían la manera en que se expresan estos bucles, para efectos de ejemplificarlos trataremos los que existen en el lenguaje java.

Analicemos la forma en que trabajan los bucles en el lenguaje java, observemos el siguiente código:

//Clase test del while curso aprenderaprogramar.com

public class testWhile {

    public static void main (String [ ] args) {

        int i = 0;

        while (true) {          //Condición trivial: siempre cierta

            i++;

            System.out.println ("Valor de i: " + i);

            if (i==9) { break;}

        }                

 } //Cierre del main

} //Cierre de la clase

Si podemos darnos cuenta lo que se ha hecho es crear una clase llamada testwhile para mostrar el funcionamiento del bucle while, lo peculiar del ejemplo es que el bucle while recibe un parámetro true lo que parece en principio que arrojara un ciclo infinito, pero ya que se insertó un sumador(i++) este va acumular la cantidad de veces que el bucle acepte el parámetro true para posteriormente mediante una estructura de control como lo es el comando if salir de la corrida cuando se llegue a la iteración 9, a pesar de ser un ejemplo sencillo podemos captar la utilidad e importancia del uso de los bucles, en este caso solo se aceptaba un valor cierto sin dar énfasis en su utilidad, pero para solucionar problemáticas donde se requiere evaluar un número de veces el valor que entra para saber si es aceptado o no este sencillo bucle sería de gran utilidad, si necesitáramos evaluar un arreglo de números

de 100 dígitos para saber cuántos de esos dígitos son pares por ejemplo, esto sería inconcebible de hacer sin el uso adecuado de un bucle.

Por otro lado están las funciones recursivas, esta no es más una función que definimos detalladamente para que al llamarse a sí misma soluciones problemas que necesariamente requieren el uso de bucles, pero esta vez se solventarían esos problemas de manera más elegante y precisa, aunque como contra se puede decir que estas funciones ocupa más espacio en memoria y son algo complejas de definir.

Para entender mejor este concepto veamos un ejemplo que permite sumar 2 números enteros en java:

/*

 *   Método recursivo que calcula la suma de dos números enteros

 */

public static int suma(int a, int b) {

    if (b == 0) {

        return a;

    } else if (a == 0) {

                  return b;

    } else {

        return 1 + suma(a, b - 1);

    }

}

En este ejemplo se define de manera detallada nuestra función recursiva, primero se establece que la función recibirá 2 números enteros mediante las variables correspondientes, con estructuras de control se establece que si alguno de estos números llega a ser 0 simplemente el valor que se arroja es el otro número, de los 2 números ser diferentes de 0 se arroja entonces el resultado haciendo un llamado al mismo método, es decir, una llamada recursiva.

Se pudo observar que a pesar de que las funciones recursivas poseen características únicas que las hacen más elegantes y más estructuradas si se puede decir, no escapan del uso de técnicas o patrones propios de los métodos iterativos con bucles, el uso de una técnica u otra dependerá exclusivamente de la habilidad del programador.

4.Conclusion

5. Bibliografía

Wikipedia, Iteración, 2015 , http://es.wikipedia.org/wiki/Iteraci%C3%B3n [consultado: martes, 21 de abril del 2015, hora: 15:22]

Wikipedia, Programacion, 2015, http://es.wikipedia.org/wiki/Programaci%C3%B3n [consultado: martes, 21 de abril del 2015, hora: 15:52]

GONZALEZ, Victorino, Estructuras de control tipo bucle en Java,2004,

http://www.desarrolloweb.com/articulos/1760.php [consultado: martes, 21 de abril del 2015, hora: 16:37]

ALVAREZ, Miguel, Funciones recursivas. Recursividad ,2008, http://www.desarrolloweb.com/articulos/funciones-recursivas-recursividad.html [consultado: martes, 21 de abril del 2015, hora: 18:17]

HERNANDEZ, Enrique, Programación Java,2013, http://puntocomnoesunlenguaje.blogspot.com/2013/01/ejemplo-recursividad-sumar-dos-numeros.html [consultado: martes, 21 de abril del 2015, hora: 18:27]