Tema: Consulta Basica sobre Recursividad.
Ver Mensaje Individual
  #6 (permalink)  
Antiguo 22/09/2008, 17:58
okram
Invitado
  
Mensajes: n/a
Puntos:
Respuesta: Consulta Basica sobre Recursividad.
@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: 
Ver original
  1. <?php
  2.  
  3. echo '<pre>';
  4.  
  5. Function Test1 () {
  6.     static $count1 = 0;
  7.  
  8.     $count1++;
  9.     echo "\$count1: $count1\n";
  10.     if ($count1 < 9) {
  11.         Test1();     
  12.     }
  13.     
  14.     $count1--;
  15.     echo "Paso por aca y \$count1 vale $count1\n";     
  16.     
  17. }  
  18.  
  19. echo "\n<b><u>Primera ejecución de Test1()</u></b>\n";
  20. 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";
  21. Test1();
  22.  
  23. echo "\n<b><u>Segunda ejecución de Test1()</u></b>\n";
  24. 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";
  25. Test1();
  26.  
  27. echo "\n==================================================================================================\n";
  28.  
  29. Function Test2 () {
  30.     static $count2 = 0;
  31.  
  32.     $count2++;
  33.     echo "\$count2: $count2\n";
  34.     if ($count2 < 9) {
  35.         Test2();     
  36.     }
  37.     
  38.     # $count2--; // No restamos lo sumado
  39.     echo "Paso por aca y \$count2 vale $count2\n";     
  40.     
  41. }  
  42.  
  43. echo "\n<b><u>Primera ejecución de Test2()</u></b>\n";
  44. echo "  A diferencia de Test1() \$count2 no es reseteada, por lo que su\n  valor final es 9\n";
  45. Test2();
  46.  
  47. echo "\n<b><u>Segunda ejecución de Test2()</u></b>\n";
  48. 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";
  49. Test2();
  50.  
  51. echo "\n<b><u>Tercera ejecución de Test2()</u></b>\n";
  52. echo "  Igual que en el caso anterior\n";
  53. Test2();
  54.  
  55. echo "\n<b><u>Cuarta ejecución de Test2()</u></b>\n";
  56. echo "  Igual que en el caso anterior\n";
  57. Test2();
  58.  
  59. echo "\n==================================================================================================\n";
  60.  
  61. Function Test3 () {
  62.     static $count3 = 0;
  63.  
  64.     $count3++;
  65.     echo "\$count3: $count3\n";
  66.     if ($count3 < 9) {
  67.         return Test3();     
  68.     }
  69.     
  70.     $count3--;
  71.     echo "Paso por aca y \$count3 vale $count3\n";     
  72.     
  73. }  
  74.  
  75. echo "\n<b><u>Primera ejecución de Test3()</u></b>\n";
  76. 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";
  77. Test3();
  78.  
  79. echo "\n<b><u>Segunda ejecución de Test3()</u></b>\n";
  80. 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";
  81. Test3();
  82.  
  83. echo "\n<b><u>Tercera ejecución de Test3()</u></b>\n";
  84. echo "  Igual que en el caso anterior\n";
  85. Test3();
  86.  
  87. echo '</pre>';
  88.  
  89. ?>

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,