在Go中递归选择子对象的有效方法？

我试图找出从Golang中的父级递归选择所有相关子级的最佳方法（顺序无关紧要），但我听说编译器没有针对递归函数和尾部递归函数进行优化，因此它们的成本很高

假设我在地图中有以下记录结构：

Legend: ID:ParentID

               1:0
           _____|_______
          /     |       \
        2:1    3:1      4:1
     ____|               |______ _______
    /    |               |      \       \
  5:2   6:2             7:4     8:4     9:4
                                 |______
                                 |      \
                                10:8    11:8
                                 |______
                                 |      \
                                12:10   13:10

如何在Go中有效地选择与父项（1）相关的所有子ID（2到13）

欢迎所有答案，包括迭代、递归、尾部递归，甚至通道尾部递归

更新：以下是我当前使用迭代方法编写的代码：

package main

import (
    "fmt"
)

type record struct {
    ID       int
    ParentID int
}

var records = make([]record, 0)

func init() {
    // Initilaize our records
    var tmpRec record
    tmpRec.ID = 1
    tmpRec.ParentID = 0
    records = append(records, tmpRec)
    tmpRec.ID = 2
    tmpRec.ParentID = 1
    records = append(records, tmpRec)
    tmpRec.ID = 3
    tmpRec.ParentID = 1
    records = append(records, tmpRec)
    tmpRec.ID = 4
    tmpRec.ParentID = 1
    records = append(records, tmpRec)
    tmpRec.ID = 5
    tmpRec.ParentID = 2
    records = append(records, tmpRec)
    tmpRec.ID = 6
    tmpRec.ParentID = 2
    records = append(records, tmpRec)
    tmpRec.ID = 7
    tmpRec.ParentID = 4
    records = append(records, tmpRec)
    tmpRec.ID = 8
    tmpRec.ParentID = 4
    records = append(records, tmpRec)
    tmpRec.ID = 9
    tmpRec.ParentID = 4
    records = append(records, tmpRec)
    tmpRec.ID = 10
    tmpRec.ParentID = 8
    records = append(records, tmpRec)
    tmpRec.ID = 11
    tmpRec.ParentID = 8
    records = append(records, tmpRec)
    tmpRec.ID = 12
    tmpRec.ParentID = 10
    records = append(records, tmpRec)
    tmpRec.ID = 13
    tmpRec.ParentID = 10
    records = append(records, tmpRec)
}

func main() {
    childIDs := getAllRelatedRecords(1)

    for _, id := range childIDs {
        fmt.Println(id)
    }
}

func getAllRelatedRecords(parentID int) []int {
    idsToProcess := make([]int, 0)
    ids := make([]int, 0)

    // Find all children of the parent.
    for i := range records {
        if records[i].ParentID == parentID {
            idsToProcess = append(idsToProcess, records[i].ID)
        }
    }

    // Find all children of each children and add each child
    // to the final list as they get processed.
    for {
        if len(idsToProcess) == 0 {
            break
        }

        // Find all children of the first child.
        for i := range records {
            if records[i].ParentID == idsToProcess[0] {
                idsToProcess = append(idsToProcess, records[i].ID)
            }
        }

        // Add first child to the final list.
        ids = append(ids, idsToProcess[0])

        // Remove first child.
        idsToProcess = append(idsToProcess[:0], idsToProcess[1:]...)
    }

    return ids
}

注意：忽略我在

记录中循环的部分，因为它只是SELECT语句的占位符

还有其他更有效的方法吗？
我无法证明这一点，但因为每个记录只有一个父项，并且您拥有的数据是每个记录的父项，所以搜索记录结构更有效

首先，我要将您的记录列表转换为从id到父项的映射：

parentMap := make(map[int]int, len(records))
for _, rec := range records {
    parentMap[rec.ID] = rec.ParentID
}

因此，您可以高效地查找每个id的父项。然后，我将创建一个映射来存储已知记录的状态：

type idStatus map[int]bool

如果地图中存在id，则表示该id的状态已知。bool指示它是否是目标parentID的子级

然后循环所有记录并沿树向上线性搜索，直到找到状态已知的记录。找到后，您可以标记在树上的搜索中找到的所有记录的状态：

func getAllRelatedRecords(parentID int) []int {
    parentMap := makeParentMap()
    status := idStatus{
        0:        false,
        parentID: true,
    }
    var lineage []int
    for _, rec := range records {
        lineage = lineage[:0]
        id := rec.ID
        for {
            if isChild, found := status[id]; found {
                status.set(lineage, isChild)
                break
            }
            lineage = append(lineage, id)
            id = parentMap[id]
        }
    }
    var ids []int
    for id, isChild := range status {
        if id == parentID {
            continue // skip the parent itself
        }
        if isChild {
            ids = append(ids, id)
        }
    }
    return ids
}

type idStatus map[int]bool

func (status idStatus) set(lineage []int, isChild bool) {
    for _, id := range lineage {
        status[id] = isChild
    }
}

func makeParentMap() map[int]int {
    parentMap := make(map[int]int, len(records))
    for _, rec := range records {
        parentMap[rec.ID] = rec.ParentID
    }
    return parentMap
}

.
您使用的是编译语言，算法不包含任何I/O，因此“昂贵”是相对的。即使编译器不进行尾部调用优化，一个简单的递归算法也可能比解释语言中的任何东西或任何涉及磁盘或网络的东西都要快。做一件简单的事情，只有在探查器高亮显示时才对其进行优化。我不太确定您希望如何选择子节点，但如果您想要所有子节点，并且不关心顺序，那么使用队列或切片进行简单的级别顺序遍历（迭代）也可以。如果符合您的需要，就不需要对级别顺序或bfs执行递归。您可以添加一些示例代码吗？@ishaan是的，我只需要它们的所有ID，而不关心顺序。您能否提供一些示例代码，说明我如何使用切片以迭代方式执行此操作？你的解决方案听起来最简单。更新：在问题中添加了我当前的代码。还有什么可以提高效率的吗？