Comment créer une structure arborescente hiérarchique à partir d'une liste de chaînes de chemins ?

Transformer une structure de chemin en arbre

Développer une structure de données imbriquée à partir d'un ensemble de chaînes de chemin peut poser des défis, en particulier lorsqu'il s'agit de pointeurs et récursivité. Étudions une solution pour créer un arbre hiérarchique à partir d'un tableau de structures de chemins.

Considérons l'exemple suivant :

s:=[]string {
  "a/b/c",
  "a/b/g",
  "a/d"
}

Notre objectif est de construire un arbre qui ressemble à la structure JSON suivante :

{
 "name": "a",
 "children": [
     {
      "name": "b",
      "children": [
        {
         "name": "c",
         "children": []
        },
        {
         "name": "g",
         "children": []
        }
      ]
    },
    {
     "name": "d",
     "children": []
    }
  ]
}

Pour y parvenir, nous implémentons une fonction récursive appelée AddToTree qui prend un arbre existant et une liste de segments de chemin.

func AddToTree(root []Node, names []string) []Node {
    if len(names) > 0 {
        var i int
        for i = 0; i < len(root); i++ {
            if root[i].Name == names[0] { //already in tree
                break
            }
        }
        if i == len(root) {
            root = append(root, Node{Name: names[0]})
        }
        root[i].Children = AddToTree(root[i].Children, names[1:])
    }
    return root
}

Cette fonction parcourt l'arbre existant pour déterminer si le nœud spécifié existe déjà. Si tel est le cas, il passe au segment suivant du chemin. Sinon, il crée un nouveau nœud avec le nom spécifié et l'ajoute à l'arborescence existante.

Example output (note that I used omitempty on the children field, because I don't like null entries in my JSONs):

[{
    "name": "a",
    "children": [{
        "name": "b",
        "children": [{
            "name": "c"
        }, {
            "name": "g"
        }]
    }, {
        "name": "d"
    }]
}]

Notre solution diffère de l'approche originale sur les aspects clés suivants :

• Il fonctionne sur une liste de nœuds plutôt que sur les enfants d'un seul nœud.
• Il crée de nouveaux nœuds au lieu de réutiliser ceux existants, évitant ainsi la duplication.
• Il vérifie les nœuds existants dans l'arborescence, en veillant à ce que chaque nœud ne soit ajouté qu'une seule fois.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!