performance - 如何在映射带有子 slice 的结构时降低时间复杂度？

Question

假设存在以下Unload结构，它是来自微服务A的单个元素响应，其中每个Item最初都有一个空的Units slice :

type Unload struct {
    UnloadCode   string
    Orders      []Order
}

type Order struct {
    OrderCode    string
    Items        []Item
}

type Item struct {
    ItemCode    string
    Units     []string
}

还有一个 ItemUnit结构，它来自微服务B:

type ItemUnit struct {
    ItemCode    string
    Units       []Unit
}

type Unit struct {
    UnitName    string
}

并且我们需要基于双方相似的 Item填充 Units， UnitName slice 及其相应的 ItemCodes值。

为了解决这个问题，我设法提出了以下解决方案:

for orderIndex, order := range unload.Orders {
    for itemIndex, item := range order.Items {
        for _, itemUnit := range itemUnits {
            if item.ItemCode == itemUnit.ItemCode {
                for _, unit := range itemUnit.Units {
                    unload.Orders[orderIndex].Items[itemIndex].Units = append(unload.Orders[orderIndex].Items[itemIndex].Units, unit.UnitName)
                }
            }
        }
    }
}

我自己不是专家，但是在我看来，此解决方案的时间复杂度很高。还有其他解决方案，更优雅，可能花费更短的时间来解决吗？

*请记住，我无法更改任何结构的结构。

Answer 1

首先，为ItemUnit创建一个映射，其中itemUnit.ItemCode作为键，而UnitName的 slice 作为值

    itemUnitmap := make(map[string][]string)
    for _, itemUnit := range itemUnits {
        var units []string
        for _, unit := range itemUnit.Units {
            units =  append(units, unit.UnitName)
        }
        itemUnitmap[itemUnit.ItemCode] = units
    }

然后使用map通过 UnitName获取 item.ItemCode的 slice 。使用可变参数将 slice 添加到 Item.Units中

   for orderIndex, order := range unload.Orders {
        for itemIndex, item := range order.Items {
            if units, ok := itemUnitmap[item.ItemCode]; ok {
                unload.Orders[orderIndex].Items[itemIndex].Units = append(unload.Orders[orderIndex].Items[itemIndex].Units, units...)// variadic function used to append slice into slice
            }
        }
    }