J'ai un fichier JSON extrait de geonames.org et je souhaite ajouter les données de ce fichier à l'aide de PHP récursif foreach fort>. Je n'ai réussi que je ne comprenais pas simplement le concept de la profondeur droite gauche. La profondeur est enregistrée correctement. P> Mon code est le suivant: P> public function buildTree($elements, $count = 1, $depth = 0)
{
if (isset($elements->geonames)) {
foreach ($elements->geonames as $element) {
$left = $count++;
$elementDB = new \App\Geo();
$elementDB->id = $element->geonameId;
$elementDB->parent_id = NULL;
$elementDB->left = $left;
$elementDB->right = $right;
$elementDB->depth = $depth;
$elementDB->name = $element->name;
$elementDB->country = $element->countryCode;
$elementDB->level = $element->fcode;
$elementDB->lat = $element->lat;
$elementDB->long = $element->lng;
$elementDB->save();
$elements = $this->getList($element->geonameId, 'element');
if ($depth < 1) {
$this->buildTree($elements, $count, $depth + 1);
}
$right = $count++;
echo "Added element " . $element->name . "\n";
}
}
}
3 Réponses :
Je suppose ici que vous faites un arbre de recherche binaire. Fondamentalement, un arbre est un graphique avec une racine, des nœuds "réguliers" et des feuilles.
Il y a toujours une seule racine, en haut, qui est un nœud particulier.
Les feuilles n'ont pas d'autres nœuds ci-dessous, ce sont les "extrémités" de l'arbre.
Les nœuds réguliers ont peut-être deux enfants, une plus petite (à gauche) et une plus grande (à droite). Cela fait quelque chose comme ça:
Comme vous pouvez le constater, tous les nœuds venant de l'enfant gauche de la racine sont plus petits que 8. Tous les enfants de droite sont plus gros que 8. De cette façon, lorsque vous recherchez "10", savez-vous immédiatement que vous avez Pour traverser le bon enfant de la racine, aucun besoin d'explorer le côté gauche (cela signifie moins de temps de traitement).
Un éventuel arborescence d'arborescence d'arborescence d'arborescence d'algorithme est la suivante: Il vous suffit de vous adapter à votre problème
Il semble que vous voulez comprendre comment cela fonctionne?
Vous utilisez la récursivité pour traiter chaque élément. Variable $ Éléments est un arbre (ou un sous-arbre) avec des nœuds. Votre code doit regarder à travers votre arbre de gauche à droite. Sur chaque itération, vous vérifiez si $ éléments a des nœuds. Si $ éléments a (cela peut être commandé ou struct avec des champs) nœuds, vous devez traiter ces nœuds. Pendant chaque vérification, vous détectez chaque noeud s'ils ont d'autres nœuds pour enfants ou non. Lorsque vous trouvez le premier (nommez-le "A") noeud qui a d'autres nœuds pour enfants, vous devez participer à la prochaine récursive d'itération pour traiter les nœuds enfants du nœud enfant actuel ("A").
Les chiffres représentent la commande dans laquelle les nœuds sont accessibles dans l'algorithme de profondeur gauche-droite.
franchement, je ne comprends pas pour ce que vous avez ajouté: et c'est une mauvaise réaffectation de style pour la variable dans peut être intéressant pour vous Quand est-il pratique d'utiliser une première recherche de profondeur-première (DFS) vs largeur (bfs)? 
Et qu'est-ce qui ne fonctionne pas avec le code donné?
Non, ça ne marche pas.
Qu'est-ce que exactement Est-ce que cela signifie? Qu'attendez-vous de ce code? Qu'avez-vous essayé de déboguer le problème?
J'ai ajouté une photo de ce qui va se passer.