php 递归函数的三种实现方式,php递归函数三种
php 递归函数的三种实现方式,php递归函数三种
递归函数是我们常用到的一类函数,最基本的特点是函数自身调用自身,但必须在调用自身前有条件判断,否则无限无限调用下去。实现递归函数可以采取什么方式呢?本文列出了三种基本方式。理解其原来需要一定的基础知识水品,包括对全局变量,引用,静态变量的理解,也需对他们的作用范围有所理解。递归函数也是解决无限级分类的一个很好地技巧。如果对无限级分类感兴趣,请参照php利用递归函数实现无限级分类。我习惯套用通俗的话解释复杂的道理,您确实不明白请参见手册。
利用引用做参数
先不管引用做不做参数,必须先明白引用到底是什么?引用不过是指两个不同名的变量指向同一块存储地址。本来每个变量有各自的存储地址,赋值删除各行其道。现在可好,两个变量共享一块存储地址。 $a=&$b; 。实际上指的是 $a 不管不顾自己原来的存储地址,非要和 $b 共享一室了。因而任何对存储地址数值的改变都会影响两个值。
函数之间本来也是各行其是,即便是同名函数。递归函数是考虑将引用作为参数,成为一个桥梁,形成两个函数间的数据共享。虽然两个函数见貌似操作的是不同地址,但是实际上操作的是一块儿内存地址。
<span>function</span> test(<span>$a</span>=0,&<span>$result</span>=<span>array</span><span>()){ </span><span>$a</span>++<span>; </span><span>if</span> (<span>$a</span><10<span>) { </span><span>$result</span>[]=<span>$a</span><span>; test(</span><span>$a</span>,<span>$result</span><span>); }<br />echo $a; </span><span>return</span> <span>$result</span><span>; }</span>
上面的例子非常简答,以$a<10作为判断条件,条件成立,则把$a赋给$result[];将$result的引用传入函数,会将每一次递归产生的$a添加到结果数组$result。因而本例生成的$result数组是 Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 [7] => 8 [8] => 9 ) 。
本例比较有意思的是echo $a 的值。相信很多人认为是12345678910吧,其实不然,是1098765432。为什么呢?因为函数还没执行echo $a前就进行了下一次的函数递归。真正执行echo $a是当$a<10条件不满足的时候,echo $a,返回$result,对于上一层而言,执行完递归函数,开始执行本层的echo $a,依次类推。
利用全局变量
利用全局变量完成递归函数,请确保你确实理解什么是全局变量。global在函数内申明变量不过是外部变量的同名引用。变量的作用范围仍然在本函数范围内。改变这些变量的值,外部同名变量的值自然也改变了。但一旦用了&,同名变量不再是同名引用。利用全局变量实现递归函数没必要理解到这么深的一层,还保持原有对全局变量的看法就可以顺理成章理解递归函数。
<span>function</span> test(<span>$a</span>=0,<span>$result</span>=<span>array</span><span>()){ </span><span>global</span> <span>$result</span><span>; </span><span>$a</span>++<span>; </span><span>if</span> (<span>$a</span><10<span>) { </span><span>$result</span>[]=<span>$a</span><span>; test(</span><span>$a,$result</span><span>); } </span><span>return</span> <span>$result</span><span>; }</span>
利用静态变量
我们常常在类中见到static,今天我们把它利用到递归函数中。请记住static的作用:仅在第一次调用函数的时候对变量进行初始化,并且保留变量值。
举个栗子:
<span>function</span><span> test(){ </span><span>static</span> <span>$count</span>=0<span>; </span><span>echo</span> <span>$count</span><span>; </span><span>$count</span>++<span>; } test(); test(); test(); test(); test();</span>
请问这一段代码的执行结果是多少?是00000么?必然不是。是01234。首先第一次调用test(),static对 $count 进行初始化,其后每一次执行完都会保留 $count 的值,不再进行初始化,相当于直接忽略了 static $count=0; 这一句。
因而将static应用到递归函数作用可想而知。在将需要作为递归函数间作为“桥梁"的变量利用static进行初始化,每一次递归都会保留"桥梁变量"的值。
<span>function</span> test(<span>$a</span>=0<span>){ </span><span>static</span> <span>$result</span>=<span>array</span><span>(); </span><span>$a</span>++<span>; </span><span>if</span> (<span>$a</span><10<span>) { </span><span>$result</span>[]=<span>$a</span><span>; test(</span><span>$a</span><span>); } </span><span>return</span> <span>$result</span><span>; }</span>
总结
所谓递归函数,重点是如何处理函数调用自身是如何保证所需要的结果得以在函数间合理"传递",当然也有不需要函数之间传值得递归函数,例如:
<span>function</span> test(<span>$a</span>=0<span>){ </span><span>$a</span>++<span>; </span><span>if</span> (<span>$a</span><10<span>) { </span><span>echo</span> <span>$a</span><span>; test(</span><span>$a</span><span>); } }</span>
面对这样的函数,我们就不必大伤脑筋了。顺便说一句,深入理解变量引用相关知识对解决这类问题大有裨益。

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Pour optimiser les performances des fonctions récursives, vous pouvez utiliser les techniques suivantes : Utiliser la récursion de queue : placez des appels récursifs à la fin de la fonction pour éviter une surcharge récursive. Mémorisation : stockez les résultats calculés pour éviter les calculs répétés. Méthode diviser pour mieux régner : décomposer le problème et résoudre les sous-problèmes de manière récursive pour améliorer l'efficacité.

Python est un langage de programmation très puissant et de nombreux programmeurs choisissent Python comme langage de programmation principal. Cependant, trop de fonctions imbriquées dans le code peuvent rendre le programme difficile à maintenir et à comprendre. Cet article explique comment résoudre l'erreur d'imbrication excessive des fonctions dans le code Python. Une brève introduction à l'imbrication de fonctions L'imbrication de fonctions fait référence au processus de définition d'une autre fonction dans le corps d'une fonction. L'imbrication de fonctions peut rendre la structure du programme plus claire et le code plus facile à lire et à maintenir. Cependant, un trop grand nombre de fonctions imbriquées peut conduire à une structure de code trop complexe.

Les fonctions récursives sont utilisées dans les algorithmes de recherche pour explorer des structures de données arborescentes. La recherche en profondeur utilise une pile pour explorer les nœuds, tandis que la recherche en largeur utilise une file d'attente pour parcourir couche par couche. Dans des applications pratiques, telles que la recherche de fichiers, les fonctions récursives peuvent être utilisées pour rechercher un fichier donné dans un répertoire spécifié.

Les conditions de sortie des fonctions récursives C++ incluent : Conditions de base : vérifiez si la fonction atteint un état qui peut renvoyer directement des résultats, en jugeant généralement si une certaine condition ou valeur de paramètre atteint le seuil. Condition de fin de récursion : Alternative ou en plus à la condition de base, garantissant que la fonction s'arrête après un certain nombre d'appels récursifs, en suivant la profondeur de récursion ou en définissant une limite maximale de profondeur de récursion.

L'application de fonctions récursives dans les algorithmes de tri en C++ Les algorithmes de tri par insertion et de tri par fusion implémentés par les fonctions récursives peuvent décomposer des problèmes complexes en sous-problèmes plus petits et les résoudre efficacement grâce à des appels récursifs. Tri par insertion : trie un tableau en insérant des éléments un par un. Tri par fusion : divisez pour mieux régner, divisez le tableau et triez récursivement les sous-tableaux, et enfin fusionnez les sous-tableaux triés.

La stratégie d'optimisation de la récursion de queue réduit efficacement la profondeur de la pile des appels de fonction et empêche le débordement de pile en convertissant les appels récursifs de queue en boucles. Les stratégies d'optimisation incluent : Détecter la récursion de queue : vérifiez s'il existe des appels récursifs de queue dans la fonction. Convertissez les fonctions en boucles : utilisez des boucles au lieu d'appels récursifs et maintenez une pile pour enregistrer l'état intermédiaire.

Comment implémenter factorielle à l'aide de fonctions récursives en langage Go ? Factorielle est un calcul courant en mathématiques qui multiplie un entier non négatif n par tous les entiers positifs plus petits que lui, jusqu'à 1. Par exemple, la factorielle de 5 peut être exprimée sous la forme 5 !, calculée comme suit : 54 321 = 120. En programmation informatique, nous utilisons souvent des fonctions récursives pour mettre en œuvre des calculs factoriels. Tout d’abord, nous devons comprendre le concept de fonctions récursives. Une fonction récursive fait référence au processus d'appel de la fonction elle-même dans le cadre de la définition de la fonction. Lors de la résolution d'un problème, une fonction récursive sera continuellement

En Golang, la récursivité est un moyen pour une fonction de s'appeler elle-même. De nombreux problèmes peuvent être résolus à l’aide de fonctions récursives, comme le calcul de factorielles, de séquences de Fibonacci, etc. Cependant, lors de l'écriture de fonctions récursives, vous devez faire attention à certains détails, sinon des erreurs de programme pourraient survenir. Cet article présentera les détails des fonctions récursives dans Golang pour aider les développeurs à écrire des fonctions récursives plus stables et fiables. Gestion des situations de base Lors de l'écriture d'une fonction récursive, il faut d'abord considérer la situation de base, c'est-à-dire les conditions de sortie de la fonction récursive. S'il n'y a pas de bonne réponse
