Kotlin 从列表重建N元树

我有以下三个值的有序列表（按外观顺序）：ID、Name和Depth

data class Node(val ID : Long, val name : String)

使用此数据集，我希望将原始N元树重建为

地图

，如下所示：

0000 : A : 0
0001 : B : 1
0002 : C : 2
0003 : D : 2
0004 : E : 1
0005 : F : 2
0006 : G : 1
0007 : H : 1
0008 : I : 2

---

完成此任务的最佳（性能最好和/或可读性最好）方法是什么？

基本思想是使用堆栈跟踪从根节点到当前处理节点的轨迹上的父节点：

A - B - C
      - D
  - E - F
  - G
  - H - I

val input=”“”
0000:A:0
0001:B:1
0002:C:2
0003:D:2
0004:E:1
0005:F:2
0006:G:1
0007:H:1
0008:I:2
"""
val parsedLines=input.split（“\n”）
.map{it.trim（）}
.filter{it.isNotEmpty（）}
.map{line->
val parsedLine=行
.split（“：”）
.map{it.trim（）}
反对{
val preOrderIndex=parsedLine[0].toInt（）
val name=parsedLine[1]
val height=parsedLine[2].toInt（）
}
}
.sortedBy{it.preOrderIndex}
parsedLines.forEach{println（${it.preOrderIndex}${it.name}${it.height}”）}
val map=HashMap（）
val parents=Stack（）
for（解析线中的nodeDesc）{
val newNode=Node（nodeDesc.preOrderIndex.toLong（），nodeDesc.name）
map[newNode]=HashSet（）
while（parents.size>nodeDesc.height）
parents.pop（）
如果（！parents.empty（））{
val tmp:HashSet？=map[parents.peek（）]
tmp！！.add（新节点）
}
parents.push（newNode）
}
println（地图）

基本思想是使用堆栈跟踪从根节点到当前处理节点的路径上的父节点：

A - B - C
      - D
  - E - F
  - G
  - H - I

val input=”“”
0000:A:0
0001:B:1
0002:C:2
0003:D:2
0004:E:1
0005:F:2
0006:G:1
0007:H:1
0008:I:2
"""
val parsedLines=input.split（“\n”）
.map{it.trim（）}
.filter{it.isNotEmpty（）}
.map{line->
val parsedLine=行
.split（“：”）
.map{it.trim（）}
反对{
val preOrderIndex=parsedLine[0].toInt（）
val name=parsedLine[1]
val height=parsedLine[2].toInt（）
}
}
.sortedBy{it.preOrderIndex}
parsedLines.forEach{println（${it.preOrderIndex}${it.name}${it.height}”）}
val map=HashMap（）
val parents=Stack（）
for（解析线中的nodeDesc）{
val newNode=Node（nodeDesc.preOrderIndex.toLong（），nodeDesc.name）
map[newNode]=HashSet（）
while（parents.size>nodeDesc.height）
parents.pop（）
如果（！parents.empty（））{
val tmp:HashSet？=map[parents.peek（）]
tmp！！.add（新节点）
}
parents.push（newNode）
}
println（地图）

给定一个

orderedList:List

可以迭代三元组，并在每个深度跟踪当前父级，以便重建树：

        val input = """
0000 : A : 0
0001 : B : 1
0002 : C : 2
0003 : D : 2
0004 : E : 1
0005 : F : 2
0006 : G : 1
0007 : H : 1
0008 : I : 2
"""
        val parsedLines = input.split("\n")
                .map { it.trim() }
                .filter { it.isNotEmpty() }
                .map { line ->
                    val parsedLine = line
                            .split(":")
                            .map { it.trim() }

                    object {
                        val preOrderIndex = parsedLine[0].toInt()
                        val name = parsedLine[1]
                        val height = parsedLine[2].toInt()
                    }
                }
                .sortedBy { it.preOrderIndex }

        parsedLines.forEach { println("${it.preOrderIndex} ${it.name} ${it.height}") }

        val map = HashMap<Node,HashSet<Node>>()
        val parents = Stack<Node>()

        for (nodeDesc in parsedLines) {
            val newNode = Node(nodeDesc.preOrderIndex.toLong(), nodeDesc.name)
            map[newNode] = HashSet<Node>()

            while (parents.size > nodeDesc.height)
                parents.pop()

            if (!parents.empty()) {
                val tmp: HashSet<Node>? = map[parents.peek()]
                tmp!!.add(newNode)
            }

            parents.push(newNode)
        }

        println(map)

---

给定一个

orderedList:List

可以迭代三元组，并在每个深度跟踪当前父级，以便重建树：

        val input = """
0000 : A : 0
0001 : B : 1
0002 : C : 2
0003 : D : 2
0004 : E : 1
0005 : F : 2
0006 : G : 1
0007 : H : 1
0008 : I : 2
"""
        val parsedLines = input.split("\n")
                .map { it.trim() }
                .filter { it.isNotEmpty() }
                .map { line ->
                    val parsedLine = line
                            .split(":")
                            .map { it.trim() }

                    object {
                        val preOrderIndex = parsedLine[0].toInt()
                        val name = parsedLine[1]
                        val height = parsedLine[2].toInt()
                    }
                }
                .sortedBy { it.preOrderIndex }

        parsedLines.forEach { println("${it.preOrderIndex} ${it.name} ${it.height}") }

        val map = HashMap<Node,HashSet<Node>>()
        val parents = Stack<Node>()

        for (nodeDesc in parsedLines) {
            val newNode = Node(nodeDesc.preOrderIndex.toLong(), nodeDesc.name)
            map[newNode] = HashSet<Node>()

            while (parents.size > nodeDesc.height)
                parents.pop()

            if (!parents.empty()) {
                val tmp: HashSet<Node>? = map[parents.peek()]
                tmp!!.add(newNode)
            }

            parents.push(newNode)
        }

        println(map)