Presentación

1. Consideraciones iniciales

Durante la presentación de la estructura de un algoritmo, discutimos brevemente la posibilidad de añadir una parte adicional al principio del programa, antes de las declaraciones de variables. Esta parte aún no se había tratado, aunque a este nivel ya sabe programar muy bien, si ha entendido correctamente los capítulos anteriores. Sin embargo, habrá notado algunas limitaciones frustrantes y, en particular, una cierta pesadez cuando el programa es muy largo y tiene que repetir ciertos bloques de instrucciones que ya están presentes en otra parte. Por ejemplo, recuerde un pequeño y sencillo programa que calcula el valor absoluto de un comando. El problema es que cada vez que quiere calcular este valor, tiene que repetir la estructura condicional. ¿No habría sido más sencillo hacerlo una sola vez y pasar a este bloque de instrucciones sólo el valor cuyo valor absoluto se quiere recuperar?

Para ello, se podría considerar un segundo programa que sería lanzado por el programa principal con este valor como argumento. Esto es técnicamente factible, pero colocar un segundo programa separado (un ejecutable) sólo para este tipo de procesamiento, es una pérdida de tiempo y espacio.

La otra solución es añadir el código necesario para este programa en una estructura especial separada del programa principal. Esto se denomina subprograma. Los lenguajes BASIC más antiguos utilizaban instrucciones para este fin (gosub, sub xxx, endsub, etc., sub para subprograma).

Cuando un programa es muy largo, no es realista programarlo todo de una sola vez. El programa se divide en pequeñas unidades o partes reutilizables, que el programa principal llama en el momento oportuno. Un subprograma evita la repetición innecesaria de código y ayuda a clarificar el programa. Una vez creados todos los subprogramas, es posible incluso guardarlos en librerías para poder reutilizarlos en otros programas, sean cuales sean, lo que simplifica enormemente la escritura de código y la hace mucho más rápida.

Un programa completo forma una aplicación. Si ha seguido correctamente las instrucciones, una aplicación se compone de varias partes funcionales:

El programa principal o bloque principal, que corresponde al bloque principal de instrucciones debajo...

Subprogramas recursivos

1. Aspectos principales

Un subprograma puede llamar a cualquier otro subprograma. Por tanto, un subprograma se puede llamar a sí mismo. Se dice que un subprograma es recursivo si está, al menos en parte, definido por sí mismo. En otras palabras, si llama a su propia función o procedimiento en una función o procedimiento, se dice que es recursivo. El ejemplo más sencillo es el factorial: ¡n!=n*(n-1)!

Existen dos tipos de recursividad:

Simple o rápido: el subprograma se llama a sí mismo.
Cruzado o indirecto: dos subprogramas se llaman entre sí: el primero llama al segundo, que a su vez llama al primero, etc.

La recursión se puede aplicar tanto a funciones como a procedimientos.

Para la recursividad simple:

Procedimiento recursivo()  
Inicio  
  /* instrucciones */  
  recursivo()  
  /* instrucciones */  
Fin

Para la recursividad cruzada:

Procedimiento recur1()  
Inicio  
  /* instrucciones */  
  recur2()  
  /* instrucciones */  
Fin  
Procedimiento recur2()  
Inicio  
  /* instrucciones */  
  recur1()  
  /* instrucciones */  
Fin

A continuación, sólo se describirán subrutinas recursivas simples.

2. Un primer ejemplo: el factorial

Un factorial es el ejemplo perfecto de aplicación de un algoritmo recursivo. Este ejemplo ya se ha presentado en capítulos anteriores, pero conviene recordarlo rápidamente:

10!=10*9*8*7*6*5*4*3*2*1
Por lo tanto, 10!=10*(9*8*7*6*5*4*3*2*1)
Así que 10 = ¡10*9!
Entonces n!=n*(n-1)!

Si creara una función (apropiada en este caso) llamada fact() para calcular el factorial de n, tendría un atajo como este:

fact(n)=n*fact(n-1)

A partir de ahí, es muy fácil escribir una función recursiva fact():

Funcion fact(n:entero) :entero  
Inicio  
  nfact(n-1)  
  Devuelve n  
Fin

Esta función no está completa porque se ejecutará hasta el infinito. No hay condición de parada. El cálculo debe continuar mientras n sea mayor que 1. Aquí están las sucesivas pasadas para un factorial de 5:

1ª etapa: 5>1?...

Ejercicios

Ejercicio 1

Cree una función que calcule la suma de valores pasados como argumentos. Esta función tendrá como primer argumento por referencia el resultado y como segundo argumento la tabla de valores. Llame a la función con un array que contenga los números 5,9,4 y 18. Escribe la solución en PHP.

Ejercicio 2

Cree una tabla que contenga 10 números aleatorios entre 1 y 100 y luego ordénela sin utilizar métodos de ordenación de tablas como sort(). Cree una función para intercambiar dos valores en una tabla. Mostrar estos valores separados por una coma. Escriba la solución en PHP.

Ejercicio 3

Cree una función que muestre aleatoriamente una frase que contenga cualquier número de palabras pasadas como argumento. Cada palabra debe aparecer sólo una vez. La función recibirá una tabla como argumento. Escriba la solución en PHP.

Ejercicio 4

Sea la tabla A con los elementos 3,8,15,16. Crea una tabla B mediante un bucle que contenga todos los elementos del 1 al 20 excepto los elementos de la tabla A. Crear una función que calcule el cubo de este número y muestre los elementos del array B en una primera columna y el cubo de los elementos de B en una segunda columna en una tabla HTML. Escriba la solución en PHP.

Ejercicio 5

Cree una función que reciba una cadena de caracteres como argumento y devuelva una cadena de caracteres utilizando...