使用Go语言将扁平化表格数据转换为树形结构

type Node struct {
    name     string    // 节点的名称
    children []*Node   // 子节点的切片，表示层级关系
}

var (
    nodeTable = map[string]*Node{} // 存储所有节点的映射，键为OrgID，值为*Node指针
    root      *Node                // 树的根节点
)

func add(id, name, parentId string) {
    node := &Node{name: name, children: []*Node{}} // 创建新节点

    if parentId == "0" { // 如果父ID为"0"，则此节点是根节点
        root = node
    } else { // 否则，查找其父节点并将其添加到父节点的子节点列表中
        parent, ok := nodeTable[parentId]
        if !ok {
            // 理论上，父节点应该在子节点之前被处理，如果未找到，可能数据有问题或处理顺序不当
            fmt.Printf("警告: 未找到父节点ID %v，节点 %v 将不会被添加到树中。\n", parentId, name)
            return
        }
        parent.children = append(parent.children, node)
    }

    nodeTable[id] = node // 将新节点添加到全局映射中，以便后续查找
}

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
)

func scan() {
    input := os.Stdin // 从标准输入读取数据
    reader := bufio.NewReader(input)
    lineCount := 0
    for {
        lineCount++
        line, err := reader.ReadString('\n') // 读取一行
        if err == io.EOF { // 读取到文件末尾
            break
        }
        if err != nil {
            fmt.Printf("读取行时发生错误: %v\n", err)
            return
        }

        // 移除行尾的换行符并按空格分割
        tokens := strings.Fields(strings.TrimSpace(line)) 

        if t := len(tokens); t != 3 { // 检查每行是否有3个字段 (OrgID, OrgName, parentID)
            fmt.Printf("输入行 %v 格式错误: 期望3个字段，实际 %d 个 [%v]\n", lineCount, t, line)
            continue
        }
        add(tokens[0], tokens[1], tokens[2]) // 调用add函数添加节点
    }
}

func showNode(node *Node, prefix string) {
    if prefix == "" { // 根节点没有前缀
        fmt.Printf("%v\n", node.name)
    } else { // 子节点使用前缀进行缩进
        fmt.Printf("%v%v\n", prefix, node.name)
    }
    for _, n := range node.children { // 递归遍历子节点
        showNode(n, prefix+"--") // 子节点的前缀增加 "--"
    }
}

func show() {
    if root == nil {
        fmt.Printf("展示: 未找到根节点，树为空。\n")
        return
    }
    fmt.Printf("结果树形结构:\n")
    showNode(root, "") // 从根节点开始展示，初始前缀为空
}

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
)

// Node 结构体定义树的节点
type Node struct {
    name     string    // 节点的名称
    children []*Node   // 子节点的切片
}

var (
    nodeTable = map[string]*Node{} // 存储所有节点的映射，键为OrgID
    root      *Node                // 树的根节点
)

// add 函数根据ID、名称和父ID创建或连接节点
func add(id, name, parentId string) {
    node := &Node{name: name, children: []*Node{}} // 创建新节点

    if parentId == "0" { // 如果父ID为"0"，则此节点是根节点
        root = node
    } else { // 否则，查找其父节点并将其添加到父节点的子节点列表中
        parent, ok := nodeTable[parentId]
        if !ok {
            fmt.Printf("警告: 未找到父节点ID %v，节点 %v 将不会被添加到树中。\n", parentId, name)
            return
        }
        parent.children = append(parent.children, node)
    }

    nodeTable[id] = node // 将新节点添加到全局映射中
}

// scan 函数从标准输入读取数据并构建树
func scan() {
    input := os.Stdin
    reader := bufio.NewReader(input)
    lineCount := 0
    for {
        lineCount++
        line, err := reader.ReadString('\n')
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Printf("读取行时发生错误: %v\n", err)
            return
        }

        tokens := strings.Fields(strings.TrimSpace(line)) // 移除行尾换行符并分割

        if t := len(tokens); t != 3 {
            fmt.Printf("输入行 %v 格式错误: 期望3个字段，实际 %d 个 [%v]\n", lineCount, t, line)
            continue
        }
        add(tokens[0], tokens[1], tokens[2])
    }
}

// showNode 函数递归地展示树的节点
func showNode(node *Node, prefix string) {
    if prefix == "" {
        fmt.Printf("%v\n", node.name)
    } else {
        fmt.Printf("%v%v\n", prefix, node.name)
    }
    for _, n := range node.children {
        showNode(n, prefix+"--")
    }
}

// show 函数开始展示树
func show() {
    if root == nil {
        fmt.Printf("展示: 未找到根节点，树为空。\n")
        return
    }
    fmt.Printf("结果树形结构:\n")
    showNode(root, "")
}

func main() {
    fmt.Printf("程序开始：从标准输入读取数据...\n")
    scan()
    fmt.Printf("数据读取完毕，开始构建和展示树...\n")
    show()
    fmt.Printf("程序结束。\n")
}