Developer's Diary

27 febrero, 2013

Por qué la recursividad mola

Filed under: .net, Curso C#, dotNetClub, Programación — 3nk1 @ 5:13 PM

Durante esta semana andan enseñando en la universidad el concepto de recursividad.

Para el que no conozca el concepto de recursividad, le puedo remitir a este blog por ejemplo http://picandocodigo.net/2008/recursividad-en-programacion/ para que aprenda lo que es.

El caso es que, al tratarse desde un punto de vista teorico y con casos prácticos muy sencillos, se llega a da entender que el concepto es completamente sustituible por una simple iteracción y claro… Pues donde este un bucle for, pues mejor que mejor. No obstante, la recursividad es un recurso que en muchas ocasiones es completamente necesario e imprescindible para poder realizar lógica en el código que de otra manera sería imposible.

Sin introducirnos en el concepto de que consume más o menos recursos ni otros aspectos.

Lo que si podemos encontrar es inconvenientes al intentar solventar problemas que encontramos en nuestras soluciones que de forma iteractiva serían imposibles o mucho más extensas en código y complicadas de implementar y mantener.

Este ejemplo que voy a poner ahora, está sacado de un problema real de código, pero por varias razones he preferido extrapolar el código a algo más sencillo aunque en el concepto resulte más absurdo.

Tenemos esta ventana:

FormRecursivo

Como se puede comprobar, cada botón va contenido en un recuadro que es un contenedor, una manera de poder organizar nuestro contenido de la ventana de una manera más eficiente y lógica. Como se puede ver, todos los paneles o contenedores, van dentro de otro y así sucesivamente. Como si de una matrioska se tratara.

Por lo tanto, el primer panel contendría un botón y dentro otro panel, pero dentro de este otro panel otro botón y otro panel. De tal manera que tenemos varios paneles, con varios botones dentro.

Ahora bien, imaginaos que queremos realizar una consulta de cuantos botones o controles, que no son paneles tenemos en esa ventana. Si intentaramos realizar tal calculo tendríamos que hacer algo así. (Lo redacto en pseudocodigo)

int cantControles = 0

Desde i = 0 hasta controles.longitud
Si controles[i] es Panel
Desde i2 = 0 hasta controles[i].longitud
Si controles[i].controles[i2] es Panel
Desde i3 = 0 hasta controles[i].controles[i2].longitud
Si controles[i].controles[i2].controles[i3] es Panel
Desde i4 = 0 hasta controles[i].controles[i2].controles[i3].longitud
Si controles[i].controles[i2].controles[i3].controles[i4] es Panel
//Así sucesivamente
Sino
cantControles = cantControles + 1
FinDesde
SiNo
cantControles = cantControles + 1
FinDesde
SiNo
cantControles = cantControles + 1
FinDesde
SiNo
cantControles = cantControles + 1
FinDesde

Como se puede ver en este pequeño pseudocodigo, la cantidad de bucles que tendríamos que hacer para llegar hasta el fondo, es igual a la cantidad de paneles que queramos alcanzar. Por lo que la situación se complica un poco cuando tenemos X paneles y modificamos algo en la pantalla o si simplemente tenemos una libreria ajena al formulario por lo que queremos aprovechar esa función para controlar varias pantallas y no solo una.

Por lo que en este caso es inevitable realizar tal operación mediante bucles o mejor dicho inviable.

Como se haría mediante recursividad. Doy una posible solución aunque supongo que habrá mejores y más funcionales. Ahora eso sí, en C#

private int ComprobarNoPaneles(Panel container)
{
int a = 0;

foreach (Control control in container.Controls)
{
if (control is Panel)
{
a += ComprobarNoPaneles((Panel)control);
}
else
{
a++;
}
}

return a;
}

Como se puede ver en el código, tenemos también una iteracción (foreach) combinada con la recursividad de volver a llamar X veces a nuestra función hasta que terminamos de localizar todos los paneles.

Hasta aquí mis dos centavos a todos los que aprendeis recursividad y pensais que nunca más la usareis, este caso práctico esta un poco fuera a lo que realmente se soluciono en el código de producción, pero creo que queda claro el concepto de que hay que tener en mente a la recursividad para resolver en algunas ocasiones estructuras repetitivas que si no fuese así, no habría manera de solventarlas.

Un saludo!

Anuncios

Dejar un comentario »

Aún no hay comentarios.

RSS feed for comments on this post. TrackBack URI

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: