如何将包含冒号分割键的二维数组转换为目录树结构？

二维数组转换为目录结构的算法

问题：

如何将一组包含冒号分隔键的二维数组转换为具有以下结构的目录树：

[
  {
    "name": "answer",
    "value": "",
    "child": [
      {
        "name": "aa",
        "value": "",
        "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",
            "value": "question:book1: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. 初始化根节点：创建一个空的字典来表示根节点。

2. 遍历每个键：对数组中的每个键执行以下步骤：

   a. 分离键：将键按冒号分隔为一个字符串数组。

   b. 临时节点变量：创建一个临时变量 t 来引用当前节点。初始时将其设置为根节点。

   c. 遍历字符串数组：通过字符串数组进行迭代：

   i. 查找现有节点：检查 t 中是否存在一个名为 k（数组中的当前字符串）的子节点。

   ii. 如果没有现有的节点：创建一个新的子节点并将其添加到 t 中。

   iii. 如果有现有的节点：将 t 移至该子节点。

   d. 处理叶子节点：如果这是最后一个键（字符串数组的最后一个元素）：

   i. 创建叶子节点：在 t 中创建一个新的子节点，将名称设置为最后一个键，值为原始键。

   ii. 将叶子节点设置为 nil：将新创建的叶子节点的 child 设置为 nil 以指示这是一个叶子节点。

3. 递归转换：算法以递归方式将每个子数组转换为目录结构。
4. 返回结果：该算法返回根节点，它是一个表示目录结构的字典。

示例代码：

package main

import (
    "encoding/json"
    "strings"
)

var 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",
}

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

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))
}

以上就是如何将包含冒号分割键的二维数组转换为目录树结构？的详细内容，更多请关注其它相关文章！