Consulta Basica sobre Recursividad.

[gabyrsh]

Hola chicos, tengo el siguiene codigo Recursivo, en el cual hay una parte que no entiendo.

Código PHP:

  Function Test () { 
    static $count = 0; 
 
    $count++; 
    echo $count; 
    if ($count < 9) { 
        Test ();      
    } 
     
    echo "Paso por aca";      
    $count--; 
     
}  
   

Esto me imprime los numeros del 1 al 9, y 9 veces la palabra "Paso por aca". Lo que no logro entender, es el por qué me imprime la frase, si estando el "IF" no tendria que permitir que la funcion llegue a imprimir la frase y solo imprimirla UNA VEZ, cuando termine de autollamarse.

desde ya un abrazo.

[the_web_saint]

Recuerda que cuando llegue a no cumplirse el if, este seguira, lo que hace que se imprima la frase, osea como se dice, viene hacia atras entonces, ejecutandose lo que est despues del if, la cantidad de veces en que llamo a la funcion.

Saludos, espero haberme explicado

[okram]

El "problema" (de hecho no lo es, sino mas bien un error de programación tuyo) es que el ejecutar (recursivamente o no) la función Test() no termina la ejecución de la función.

Ejemplo: Yo tengo una función que ejecuta a, b y c. b es un proceso que llama nuevamente a la función hasta que se ha ejecutado 3 veces. Tienes entonecs la siguiente estructura de procesos a realizar:

Código:

Funcion:
a
b // Llama recursivamente a la función
c

Llamado a la función:
a
b // Llamando nuevamente a la función - 1
  a
  b // Llamando nuevamente a la función - 2
    a
    b // Llamando nuevamente a la función - 3
      a
      b // 4 - No se ejecuta este proceso, ya no llama a la función. Ahora falta ejecutar el proceso c, que se fue acumulando
      c // Proceso c del 3er llamado a la función
    c // Proceso c del 2do llamado a la función
  c // Proceso c del 1er llamado a la función
c // Proceso c del llamado original a la función

La "solución" (como ya te dije, no es un problema) es utilizar el keyword return en cada llamado recursivo a la función, lo que hará que su ejecución termine. El árbol de procesos quedaría así: (b ahora es un proceso que llama a la función y termina su ejecución, impidiendo que se ejecute c)

Código:

Funcion:
a
b // Llama recursivamente a la función y termina la ejecución actual usando un return
c

Llamado a la función:
a
b // Llamando nuevamente a la función terminando esta ejecución - 1
  a
  b // Llamando nuevamente a la función terminando esta ejecución - 2
    a
    b // Llamando nuevamente a la función terminando esta ejecución - 3
      a
      b // 4 - No se ejecuta, ya no llama a la función ni termina la ejecución actual
      c // Proceso c del 3er llamado a la función

Espero me hayas entendido, aplica el mismo criterio a tu función, usando return antes de Test() para finalizar así la ejecución actual

Saludos,

[gabyrsh]

Hola, gracias por responder, en si, no era un problema de programacion mia, solo es que no entendia esa funcion de recursividad que encontré en un manual de PHP, y sabia que en algun lugar tenia que poner el return, pero no sabia donde.

Les Agradesco las explicaciones, me fueron muy util para poder entenderlo.

Desde Ya, muchas gracias por todo.

Un abrazo.

[pateketrueke]

que no es por el count++ y count-- ??? (así nunca avanzaría)

y yo creo, que si como programador no te fijas.... no es culpa de PHP sino de uno mismo, suerte!

[okram]

@pateketrueke, $count-- no tiene utilidad práctica en ese código, pues esa porción del código se efectúa terminada la recursividad, cuando la función ya no hará nada más. Por lo tanto, sólo tiene influencia en el valor final de $count, mas no en la salida de impresión. En el árbol de procesos que puse más arriba es la porción c del código, la cual se ejecuta todo en conjunto al final de todos los demás procesos. Prueba:

Código php:

<?php
 
echo '<pre>';
 
Function Test1 () {
    static $count1 = 0;
 
    $count1++;
    echo "\$count1: $count1\n";
    if ($count1 < 9) {
        Test1();     
    }
    
    $count1--;
    echo "Paso por aca y \$count1 vale $count1\n";     
    
}  
 
echo "\n<b><u>Primera ejecución de Test1()</u></b>\n";
echo "  Se ejecuta la función recursivamente 9 veces, y el último bloque\n  se imprime al final resetando \$count1 9 veces hasta su valor original\n";
Test1();
 
echo "\n<b><u>Segunda ejecución de Test1()</u></b>\n";
echo "  Como \$count1 fue reseteada, la función se ejecuta de nuevo\n  exactamente igual que en el primer caso. Vemos que siempre \$count1\n  regresa a su valor original\n";
Test1();
 
echo "\n==================================================================================================\n";
 
Function Test2 () {
    static $count2 = 0;
 
    $count2++;
    echo "\$count2: $count2\n";
    if ($count2 < 9) {
        Test2();     
    }
    
    # $count2--; // No restamos lo sumado
    echo "Paso por aca y \$count2 vale $count2\n";     
    
}  
 
echo "\n<b><u>Primera ejecución de Test2()</u></b>\n";
echo "  A diferencia de Test1() \$count2 no es reseteada, por lo que su\n  valor final es 9\n";
Test2();
 
echo "\n<b><u>Segunda ejecución de Test2()</u></b>\n";
echo "  El valor inicial de \$count1 es 9; antes de efecutar la\n  recursividad, se le agrega 1, por lo que no pasa el condicional\n  para ejecutarse recursivamente, por eso la función sólo se\n  ejecuta una vez\n";
Test2();
 
echo "\n<b><u>Tercera ejecución de Test2()</u></b>\n";
echo "  Igual que en el caso anterior\n";
Test2();
 
echo "\n<b><u>Cuarta ejecución de Test2()</u></b>\n";
echo "  Igual que en el caso anterior\n";
Test2();
 
echo "\n==================================================================================================\n";
 
Function Test3 () {
    static $count3 = 0;
 
    $count3++;
    echo "\$count3: $count3\n";
    if ($count3 < 9) {
        return Test3();     
    }
    
    $count3--;
    echo "Paso por aca y \$count3 vale $count3\n";     
    
}  
 
echo "\n<b><u>Primera ejecución de Test3()</u></b>\n";
echo "  En Test3() aplicamos el mismo algoritmo que en Test1(), con la\n  diferencia que Test3() ejecuta la recursividad terminando la\n  ejecución actual\n";
Test3();
 
echo "\n<b><u>Segunda ejecución de Test3()</u></b>\n";
echo "  Como en la ejecución anterior la recursividad terminaba con la\n  ejecución de la función, el último bloque sólo se ejecutará si\n  la condición establecida no se cumple y la función no entra en\n  recursividad. Por lo tanto, el puntero no reseteado no cumple\n  la condición y la función no entra a la recursividad\n";
Test3();
 
echo "\n<b><u>Tercera ejecución de Test3()</u></b>\n";
echo "  Igual que en el caso anterior\n";
Test3();
 
echo '</pre>';
 
?>
 

Imprime

Código:

Primera ejecución de Test1()
  Se ejecuta la función recursivamente 9 veces, y el último bloque
  se imprime al final resetando $count1 9 veces hasta su valor original
$count1: 1
$count1: 2
$count1: 3
$count1: 4
$count1: 5
$count1: 6
$count1: 7
$count1: 8
$count1: 9
Paso por aca y $count1 vale 8
Paso por aca y $count1 vale 7
Paso por aca y $count1 vale 6
Paso por aca y $count1 vale 5
Paso por aca y $count1 vale 4
Paso por aca y $count1 vale 3
Paso por aca y $count1 vale 2
Paso por aca y $count1 vale 1
Paso por aca y $count1 vale 0

Segunda ejecución de Test1()
  Como $count1 fue reseteada, la función se ejecuta de nuevo
  exactamente igual que en el primer caso. Vemos que siempre $count1
  regresa a su valor original
$count1: 1
$count1: 2
$count1: 3
$count1: 4
$count1: 5
$count1: 6
$count1: 7
$count1: 8
$count1: 9
Paso por aca y $count1 vale 8
Paso por aca y $count1 vale 7
Paso por aca y $count1 vale 6
Paso por aca y $count1 vale 5
Paso por aca y $count1 vale 4
Paso por aca y $count1 vale 3
Paso por aca y $count1 vale 2
Paso por aca y $count1 vale 1
Paso por aca y $count1 vale 0

==================================================================================================

Primera ejecución de Test2()
  A diferencia de Test1() $count2 no es reseteada, por lo que su
  valor final es 9
$count2: 1
$count2: 2
$count2: 3
$count2: 4
$count2: 5
$count2: 6
$count2: 7
$count2: 8
$count2: 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9
Paso por aca y $count2 vale 9

Segunda ejecución de Test2()
  El valor inicial de $count1 es 9; antes de efecutar la
  recursividad, se le agrega 1, por lo que no pasa el condicional
  para ejecutarse recursivamente, por eso la función sólo se
  ejecuta una vez
$count2: 10
Paso por aca y $count2 vale 10

Tercera ejecución de Test2()
  Igual que en el caso anterior
$count2: 11
Paso por aca y $count2 vale 11

Cuarta ejecución de Test2()
  Igual que en el caso anterior
$count2: 12
Paso por aca y $count2 vale 12

==================================================================================================

Primera ejecución de Test3()
  En Test3() aplicamos el mismo algoritmo que en Test1(), con la
  diferencia que Test3() ejecuta la recursividad terminando la
  ejecución actual
$count3: 1
$count3: 2
$count3: 3
$count3: 4
$count3: 5
$count3: 6
$count3: 7
$count3: 8
$count3: 9
Paso por aca y $count3 vale 8

Segunda ejecución de Test3()
  Como en la ejecución anterior la recursividad terminaba con la
  ejecución de la función, el último bloque sólo se ejecutará si
  la condición establecida no se cumple y la función no entra en
  recursividad. Por lo tanto, el puntero no reseteado no cumple
  la condición y la función no entra a la recursividad
$count3: 9
Paso por aca y $count3 vale 8

Tercera ejecución de Test3()
  Igual que en el caso anterior
$count3: 9
Paso por aca y $count3 vale 8

Verás que aunque en la primera se hace el count-- y en la segunda no, se imprimen el mismo número de líneas, variando sólo el valor de $count con que termina cada ejecución. ¿Qué repercusión tiene esto? Que si no se realiza el $count-- la función sólo responderá bien en su primera ejecución, mas no entrará en recursividad en una segunda ejecución, pues el puntero $count no fue reseteado.

Saludos,

[pateketrueke]

@okram, simplemente genial!! (yo andaba supongo)

gracias...

[gabyrsh]

Tengo el siguiente problema, a ver si temrmino de entender. por ejemplo hago:

Código PHP:

   
function funcionrecursiva() 
{ 
  static $count = 0; 
   
  if ($count < 9) 
   { 
     //echo $count; 
     $count ++; 
     funcionrecursiva();       
 
   }    
 else 
   { 
     return $count;    
   } 
}  
   

Y en la llamada de la funcion pongo :

Código PHP:

  $contador = funcionrecursiva(); 
        echo $contador;  
   

Pero la variable $contador no tiene nada. Que estoy haciendo mal? Creo que me tendria que devolver un 8, no es asi?.

[pateketrueke]

es que te falta devolver también funcionrecursiva(); no mas, suerte!

y de hecho devuelve un 9 ya que incrementas antes de devolver...

[gabyrsh]

es que te falta devolver también funcionrecursiva(); no mas, suerte!

y de hecho devuelve un 9 ya que incrementas antes de devolver...

Gracias por la repsuesta, pero no entendi, , que linea tendria que modificar para devolver funcionrecursiva();?

[GatorV]

donde haces la comparación para ver si es menor a 9, te falta regresar el valor de tu función recursiva.

Saludos.

[gabyrsh]

Es decir, quedaria asi, no?

Código PHP:

    if ($count < 9) 
   { 
     //echo $count; 
     $count ++; 
     
   return funcionrecursiva();       
 
   }  
   

[GatorV]

Así es.

Saludos.

[gabyrsh]

Gracias, por fin me ha salido!!!
un abrazo.