Algoritmos y Estructuras de Datos

Conversión de un programa recursivo a la cola

en un programa iterativo

El presente documento explica el procedimiento para transformar un pro-

grama recursivo simple a la cola (tail recursion) en un programa iterativo.
Un programa recursivo simple es aquel que tiene una sola llamada re-
cursiva en su cuerpo. La propiedad de “a la cola” hace referencia a que la
llamada recursiva es lo último que se ejecuta en el cuerpo del programa. El
siguiente es un ejemplo de un programa que respeta esta propiedad:

int tail_recursive(int x){

if (corte_recursion(x)){
return x;
} else {
sentencia_1;
sentencia_n;
return tail_recursive(y);
}
}

Mientras que el siguiente programa NO es recursivo a la cola:

int no_tail(int x){

if (corte_recursion(x)){
return x;
} else {
sentencia_1;
y = no_tail(y);
sentencia_n;
return y;
}
}

1
 A los fines de describir el procedimiento de transformación del recursivo
a la cola vamos a necesitar las siguientes definiciones:
Sea f la función recursiva a la cola a transformar. Sean:
• T1 el producto cartesiano de los parámetros de f que sufren cambios
entre cada llamada de la recursión.
• T2 el producto cartesiano de los parámetros de f que permanencen
inalterados entre cada llamada recursiva.
• T3 el producto cartesiano de los parámetros devueltos como resultado
de la función f .
• d : T1 × T2 → boolean una función booleana que define la condición de
corte de la recursión.
• s : T1 × T2 → T1 una función que realiza los cambios en los valores de
los parámetros en el cuerpo de la función recursiva.
• h : T1 × T2 → T3 una función que define el resultado de la función f .
Entonces la función recursiva a la cola f : T1 × T2 → T3 queda definida
como:
∀t1 : T1 , t2 : T2 :

h(t1 , t2 ) d(t1 , t2 ) = true
f (t1 , t2 ) =
f (s(t1 , t2 ), t2 ) d(t1 , t2 ) = f alse
Dicha función f puede ser entonces transformada en un programa itera-
tivo de la forma:

while (!d(t1,t2)){
t1 = s(t1,t2);
}
return h(t1,t2);

Puede verse que la condición de corte de recursión es la condición de salida

del bucle, que la función s es la que define los cálculos dentro del cuerpo del
bucle, y que el resultado final es obtenido aplicando la función h al valor que
asumen los parámetros a la finalización del bucle.
A continuación se presenta un ejemplo de esta transformación para el
caso del algoritmo de la división entera.
La función de división entera (de) toma dos parámetros, dividendo d y
divisor q y devuelve el cociente c y el resto r. Supongamos que son todos
números Naturales.

2
 De esta forma la función de queda definida como:

de : N × N → N × N

Para obtener una función recursiva a la cola para este caso necesitamos
de un parámetro adicional que permita acumular el valor del cociente que va
cambiando entre cada llamada de la recursión. Ası́ definimos:

deaux : N × N × N → N × N

haciendo que la función original sea resuelta mediante la llamada a la función

auxiliar:

de(d, q) = deaux(d, q, 0)

asignando el valor cero (0) al parámetro agregado. La función auxiliar deaux

es la función recursiva que ejecutará el cómputo. Esta queda definida como:

(c, d) d<q
deaux(d, q, c) =
deaux(d − q, q, c + 1) d ≥ q
Ahora veamos como esta función es transformada en un programa itera-
tivo. Para ello tenemos que determinar cuales son los dominios T1 , T2 y T3 y
las funciones d, h y s utilizadas para el caso general.
Como tenemos que:

deaux : N × N × N → N × N

y visto que en la definición de la misma el parámetro q no cambia de valor

entre llamadas recursivas (representa el divisor que es constante), entonces
los dominios y las funciones quedan definidos como:

• T1 : N × N
• T2 : N
• T3 : N × N
• d(d, q, c) : d < q
• s(d, q, c) : (d − q, c + 1)
• h(d, q, c) : (c, d)

Aplicando la regla general de transformación para este caso, el programa

iterativo queda como:

3
deaux(d,q,c)
while (!(d<q)){
d = d-q;
c = c+1;
}
return (c,d);

teniendo en cuenta que el valor de retorno debe ser una estructura que pueda
contener al cociente c y al resto d como resultado.