如何用 Go 语言将二维数组转化为类似 RDM 的目录树结构？

二维数组转目录结构：一种便捷高效的 go 语言算法

想要实现类似 rdm 的目录树结构？但苦思冥想却难有突破？别担心，这篇文章将为你提供一个简洁高效的 go 语言解决方案，帮你在复杂的数据中理出清晰的条理。

任务：将给定的二维数组转换为如 rdm 般的目录树结构。数组中元素由冒号（:）分隔，表示目录层级关系。

示例输入：

values := []string{
    "answer:aa:bb",
    "answer:aa:cc",
    "question:book1",
    "question:book1:answer",
    "question:book1:answer:name1",
    "question:book1:answer:name2",
    "timeout_1",
    "timeout_2",
}

预期输出：

Nanonets

基于AI的自学习OCR文档处理，自动捕获文档数据

下载

[
    {
        "name": "answer",
        "child": [
            {
                "name": "aa",
                "child": [
                    {
                        "name": "bb",
                        "value": "answer:aa:bb",
                        "child": []
                    },
                    {
                        "name": "cc",
                        "value": "answer:aa:cc",
                        "child": []
                    }
                ]
            }
        ]
    },
    {
        "name": "question",
        "child": [
            {
                "name": "book1",
                "value": "question:book1",
                "child": [
                    {
                        "name": "answer",
                        "child": [
                            {
                                "name": "name1",
                                "value": "question:book1:answer:name1",
                                "child": []
                            },
                            {
                                "name": "name2",
                                "value": "question:book1:answer:name2",
                                "child": []
                            }
                        ]
                    }
                ]
            }
        ]
    },
    {
        "name": "timeout_1",
        "value": "timeout_1",
        "child": []
    },
    {
        "name": "timeout_2",
        "value": "timeout_2",
        "child": []
    }
]

算法步骤：

1. 初始化一个根节点映射表 root。
2. 遍历给定的数组值。
3. 将数组值按冒号分隔为键列表 keys。
4. 按键列表的顺序遍历 root。如果遇到的键是现有子节点，则进入该子节点的映射表中；否则，创建一个新子节点并进入该子节点的映射表中。
5. 对于键列表中的最后一个键（表示叶子节点），创建一个只包含名称和值的节点，并将其添加到当前子节点映射表中。

最终代码：

package main

import (
    "encoding/json"
    "strings"
)

func main() {
    root := make(map[string]Node)

    for _, value := range values {
        t := root
        keys := strings.Split(value, ":")
        l := len(keys)
        for i := 0; i < l-1; i++ {
            k := keys[i]
            if tm, has := t[k]; has {
                t = tm.Child
            } else {
                t[k] = Node{
                    Name:  k,
                    Child: map[string]Node{},
                }
                t = t[k].Child
            }
        }
        t[value] = Node{
            Name:  keys[l-1],
            Value: value,
            Child: nil,
        }
    }
    r, _ := json.Marshal(root)
    println(string(r))
}

type Node struct {
    Name  string
    Value string
    Child map[string]Node
}

运用此算法，你可以轻而易举地实现任意复杂性的二维数组到目录树的转换，并生成清晰、美观的树状结构。