Question

只是练习并注意到很容易序列化（通过深度优先搜索遍历）bst并将其反序列化回树中。但是，如果序列化是通过面包优先搜索遍历完成的，那么我很难对其进行反序列化。

例如，给定输入：5,2,11，N，3,7,19，N，N，6,8，N，N，N，N，N，N 寻找输出 -

      5
    /   \
   2     11
  / \    /  \
 N   3  7    19
      / \    / \
     6   8  N   N
    /\  / \
   N  N N N

Answer 1

请记住，这是二进制树搜索，这意味着每个节点只有两个子节点，左右。

（假设N代表Null / no节点）：建立你的树。输入序列中的第一个元素是根元素，接下来的两个元素被指定为根的左子元素，然后是右子元素。然后使用bfs走下你的树。如果孩子是N，则转到下一个孩子，如果孩子是值，则将输入序列中的后两个值指定为该节点的左右孩子。所以。

例子：
5,2,11，N，3,7,19，N，N，6,8，N，N，N，N，N，N
以root身份分配5。

将5视为节点 - ＆gt;这是一个价值，分配孩子：
2,11，N，3,7,19，N，N，6,8，N，N，N，N，N，N // 5处理后的剩余输入
将2分配为左孩子。
11，N，3,7,19，N，N，6,8，N，N，N，N，N，N
将11分配为正确的孩子。
//在第0部分完成整个广度

将2视为节点 - ＆gt;这是一个价值，分配孩子：
N，3,7,19，N，N，6,8，N，N，N，N，N，N
将N指定为左子 3,7,19，N，N，6,8，N，N，N，N，N，N
将3分配为正确的孩子。

将11视为节点 - ＆gt;这是一个价值，分配孩子：
7,19，N，N，6,8，N，N，N，N，N，N
将7分配为左孩子。
19，N，N，6,8，N，N，N，N，N，N
将19分配为正确的孩子 //在深度上完成整个广度1

将N视为节点 - ＆gt;不是值，继续下一个广度节点将3视为节点 - ＆gt;这是一个价值，分配孩子：
N，N，6,8，N，N，N，N，N，N
将N指定为左子 N，6,8，N，N，N，N，N，N
将N指定为正确的孩子。

将7视为节点 - ＆gt; ......等。

在分析输入字符串时构建树，并使用广度优先搜索到达此构建树中的下一个叶子，如果它具有有效值，则它将在输入字符串中分配下两个元素作为左右儿童。

Answer 2

要反序列化通过广度优先遍历生成的字符串，您基本上使用相同的机制。使用一个队列，在该队列中引用应该注入新子项的位置。当您注入一个新的子节点时，在队列中再添加两个引用，每个子节点一个。

由于队列是FIFO，因此注入子项将以广度第一顺序发生。

以下是Python的外观：

def to_tree(serialised):
    container = [None]
    leaves = [[container, 0]] # put the reference to the root on the queue

    for value in serialised.split(","):
        children, childIndex = leaves.pop(0) # pull from queue
        if value != 'N':
            node = children[childIndex] = {
                "value": value,
                "children": [None, None]
            }
            # append the new 2 child references to the queue
            leaves.append([node["children"], 0])
            leaves.append([node["children"], 1])
        if len(leaves) == 0: # should not happen if input is complete
            break 

    return container[0] # return the root

# Example call
tree = to_tree("5,2,11,N,3,7,19,N,N,6,8,N,N,N,N,N,N")

# Output the result in JSON format
import json
print(json.dumps(tree, indent=2))

以上的输出是：

{
  "value": "5",
  "children": [
    {
      "value": "2",
      "children": [
        null,
        {
          "value": "3",
          "children": [
            null,
            null
          ]
        }
      ]
    },
    {
      "value": "11",
      "children": [
        {
          "value": "7",
          "children": [
            {
              "value": "6",
              "children": [
                null,
                null
              ]
            },
            {
              "value": "8",
              "children": [
                null,
                null
              ]
            }
          ]
        },
        {
          "value": "19",
          "children": [
            null,
            null
          ]
        }
      ]
    }
  ]
}

从字符串反序列化二进制搜索树

2 个答案: