programacion iterativa

1. 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.253
Fernández G. Ana B. C.I. 21.329.313

2. Contenido
1. 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

3. 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.

4. 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.

5. 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.

6. 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;}
}

7. } // 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.

8. 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

9. 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

10. 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.

11. 4.Conclusion

12. 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]