バイナリツリーをシリアル化する方法
今日のインタビューに行って、バイナリツリーのシリアル化を依頼されました。ノードi（レベル順トラバーサルでの番号付け）の子が左の子では2 * iインデックス、右の子では2 * i + 1である配列ベースのアプローチを実装しました。面接官は多かれ少なかれ満足しているように見えましたが、シリアル化が正確に何を意味するのか疑問に思いますか？具体的には、ディスクに書き込むためにツリーをフラット化することに関するものですか、またはツリーをシリアル化することには、たとえばツリーをリンクされたリストに変換することも含まれます。また、ツリーを（二重に）リンクされたリストにフラット化してから、それを再構築するにはどうすればよいでしょうか。リンクされたリストからツリーの正確な構造を再現できますか？
これらの記事はすべて、主にシリアライゼーションの部分について述べています。逆シリアル化の部分は、1つのパスで行うには少し注意が必要です。
逆シリアル化のための効率的なソリューションも実装しました。
問題：正の数を含むバイナリツリーをシリアル化および逆シリアル化する。
シリアライズ部：
- Nullを表すには0を使用します。
- プリオーダートラバーサルを使用して整数のリストにシリアル化します。
デシリアライゼーション部分：
- 整数のリストを受け取り、再シリアル化に再帰ヘルパーメソッドを使用します。
- 再帰的デシリアライザーはペア（BTNodeノード、int nextIndexToRead）を返します。ノードはこれまでに作成されたツリーノードであり、nextIndexToReadは数値のシリアル化されたリストで読み取られる次の数値の位置です。
以下はJavaのコードです：
public final class BinaryTreeSerializer
{
public static List<Integer> Serialize(BTNode root)
{
List<Integer> serializedNums = new ArrayList<Integer>();
SerializeRecursively(root, serializedNums);
return serializedNums;
}
private static void SerializeRecursively(BTNode node, List<Integer> nums)
{
if (node == null)
{
nums.add(0);
return;
}
nums.add(node.data);
SerializeRecursively(node.left, nums);
SerializeRecursively(node.right, nums);
}
public static BTNode Deserialize(List<Integer> serializedNums)
{
Pair pair = DeserializeRecursively(serializedNums, 0);
return pair.node;
}
private static Pair DeserializeRecursively(List<Integer> serializedNums, int start)
{
int num = serializedNums.get(start);
if (num == 0)
{
return new Pair(null, start + 1);
}
BTNode node = new BTNode(num);
Pair p1 = DeserializeRecursively(serializedNums, start + 1);
node.left = p1.node;
Pair p2 = DeserializeRecursively(serializedNums, p1.startIndex);
node.right = p2.node;
return new Pair(node, p2.startIndex);
}
private static final class Pair
{
BTNode node;
int startIndex;
private Pair(BTNode node, int index)
{
this.node = node;
this.startIndex = index;
}
}
}
public class BTNode
{
public int data;
public BTNode left;
public BTNode right;
public BTNode(int data)
{
this.data = data;
}
}
アプローチ1：InorderトラバースとPreorderトラバースの両方を実行して、ツリーデータをシリアル化します。逆シリアル化でPre-orderを使用し、InorderでBSTを実行して、ツリーを適切に形成します。
A-> B-> Cは構造が異なっていても、プレオーダーとして表現できるため、両方が必要です。
アプローチ2：左または右の子がnullである場合は常に＃を歩哨として使用します。
事前順序トラバーサルを使用して、バイナリツリーをシリアル化します。ツリーをデシリアライズするには、同じ事前順序トラバーサルを使用します。 Edgeのケースに注意してください。ここではnullノードは「＃」で表されます
public static String serialize(TreeNode root){
StringBuilder sb = new StringBuilder();
serialize(root, sb);
return sb.toString();
}
private static void serialize(TreeNode node, StringBuilder sb){
if (node == null) {
sb.append("# ");
} else {
sb.append(node.val + " ");
serialize(node.left, sb);
serialize(node.right, sb);
}
}
public static TreeNode deserialize(String s){
if (s == null || s.length() == 0) return null;
StringTokenizer st = new StringTokenizer(s, " ");
return deserialize(st);
}
private static TreeNode deserialize(StringTokenizer st){
if (!st.hasMoreTokens())
return null;
String val = st.nextToken();
if (val.equals("#"))
return null;
TreeNode root = new TreeNode(Integer.parseInt(val));
root.left = deserialize(st);
root.right = deserialize(st);
return root;
}
私はそれの要点を取得しようとしています。だからここに私のJava実装があります。前述のように、これはBSTではなくバイナリツリーです。シリアル化の場合、プレオーダートラバーサルは（nullノードの「NULL」を含む文字列に対して）簡単に機能するようです。 ）再帰呼び出しの完全な例を使用して以下のコードを確認してください。逆シリアル化では、文字列はLinkedListに変換され、remove（0）はO(1) runningの最上位要素を取得します時間。デシリアライズ用のコードのコメントにある完全な例も参照してください。誰かが私よりも苦労しなくて済むように願っています:)各メソッドの全体的な実行時間（シリアライズとデシリアライズ）は、バイナリツリートラバーサルの実行時間と同じですつまり、O(n)ここで、nはツリー内のノード（エントリ）の数です。
import Java.util.LinkedList; import Java.util.List;
パブリッククラスSerDesBinTree {
public static class TreeEntry<T>{
T element;
TreeEntry<T> left;
TreeEntry<T> right;
public TreeEntry(T x){
element = x;
left = null;
right = null;
}
}
TreeEntry<T> root;
int size;
StringBuilder serSB = new StringBuilder();
List<String> desList = new LinkedList<>();
public SerDesBinTree(){
root = null;
size = 0;
}
public void traverseInOrder(){
traverseInOrder(this.root);
}
public void traverseInOrder(TreeEntry<T> node){
if (node != null){
traverseInOrder(node.left);
System.out.println(node.element);
traverseInOrder(node.right);
}
}
public void serialize(){
serialize(this.root);
}
/*
* 1
* / \
* 2 3
* /
* 4
*
* ser(1)
* serSB.append(1) serSB: 1
* ser(1.left)
* ser(1.right)
* |
* |
* ser(1.left=2)
* serSB.append(2) serSB: 1, 2
* ser(2.left)
* ser(2.right)
* |
* |
* ser(2.left=null)
* serSB.append(NULL) serSB: 1, 2, NULL
* return
* |
* ser(2.right=null)
* serSB.append(NULL) serSB: 1, 2, NULL, NULL
* return
*
* |
* ser(1.right=3)
* serSB.append(3) serSB: 1, 2, NULL, NULL, 3
* ser(3.left)
* ser(3.right)
*
* |
* ser(3.left=4)
* serSB.append(4) serSB: 1, 2, NULL, NULL, 3, 4
* ser(4.left)
* ser(4.right)
*
* |
* ser(4.left=null)
* serSB.append(NULL) serSB: 1, 2, NULL, NULL, 3, 4, NULL
* return
*
* ser(4.right=null)
* serSB.append(NULL) serSB: 1, 2, NULL, NULL, 3, 4, NULL, NULL
* return
*
* ser(3.right=null)
* serSB.append(NULL) serSB: 1, 2, NULL, NULL, 3, 4, NULL, NULL, NULL
* return
*
*/
public void serialize(TreeEntry<T> node){
// preorder traversal to build the string
// in addition: NULL will be added (to make deserialize easy)
// using StringBuilder to append O(1) as opposed to
// String which is immutable O(n)
if (node == null){
serSB.append("NULL,");
return;
}
serSB.append(node.element + ",");
serialize(node.left);
serialize(node.right);
}
public TreeEntry<T> deserialize(TreeEntry<T> newRoot){
// convert the StringBuilder into a list
// so we can do list.remove() for the first element in O(1) time
String[] desArr = serSB.toString().split(",");
for (String s : desArr){
desList.add(s);
}
return deserialize(newRoot, desList);
}
/*
* 1
* / \
* 2 3
* /
* 4
*
* deser(root, list) list: 1, 2, NULL, NULL, 3, 4, NULL, NULL, NULL
* root = new TreeEntry(1) list: 2, NULL, NULL, 3, 4, NULL, NULL, NULL
* root.left = deser(root.left, list) // **
* root.right = deser(root.right, list) // *-*
* return root // ^*^
*
*
* so far subtree
* 1
* / \
* null null
*
* deser(root.left, list)
* root.left = new TreeEntry(2) list: NULL, NULL, 3, 4, NULL, NULL, NULL
* root.left.left = deser(root.left.left, list) // ***
* root.left.right = deser(root.left.right, list) // ****
* return root.left // eventually return new TreeEntry(2) to ** above after the two calls are done
*
* so far subtree
* 2
* / \
* null null
*
* deser(root.left.left, list)
* // won't go further down as the next in list is NULL
* return null // to *** list: NULL, 3, 4, NULL, NULL, NULL
*
* so far subtree (same, just replacing null)
* 2
* / \
* null null
*
* deser(root.left.right, list)
* // won't go further down as the next in list is NULL
* return null // to **** list: 3, 4, NULL, NULL, NULL
*
* so far subtree (same, just replacing null)
* 2
* / \
* null null
*
*
* so far subtree // as node 2 completely returns to ** above
* 1
* / \
* 2 null
* / \
* null null
*
*
* deser(root.right, list)
* root.right = new TreeEntry(3) list: 4, NULL, NULL, NULL
* root.right.left = deser(root.right.left, list) // *&*
* root.right.right = deser(root.right.right, list) // *---*
* return root.right // eventually return to *-* above after the previous two calls are done
*
* so far subtree
* 3
* / \
* null null
*
*
* deser(root.right.left, list)
* root.right.left = new TreeEntry(4) list: NULL, NULL, NULL
* root.right.left.left = deser(root.right.left.left, list) // *(*
* root.right.left.right = deser(root.right.left.right, list) // *)*
* return root.right.left // to *&*
*
* so far subtree
* 4
* / \
* null null
*
* deser(root.right.left.left, list)
* // won't go further down as the next in list is NULL
* return null // to *(* list: NULL, NULL
*
* so far subtree (same, just replacing null)
* 4
* / \
* null null
*
* deser(root.right.left.right, list)
* // won't go further down as the next in list is NULL
* return null // to *)* list: NULL
*
*
* so far subtree (same, just replacing null)
* 4
* / \
* null null
*
*
* so far subtree
* 3
* / \
* 4 null
* / \
* null null
*
*
* deser(root.right.right, list)
* // won't go further down as the next in list is NULL
* return null // to *---* list: empty
*
* so far subtree (same, just replacing null of the 3 right)
* 3
* / \
* 4 null
* / \
* null null
*
*
* now returning the subtree rooted at 3 to root.right in *-*
*
* 1
* / \
* / \
* / \
* 2 3
* / \ / \
* null null / null
* /
* 4
* / \
* null null
*
*
* finally, return root (the tree rooted at 1) // see ^*^ above
*
*/
public TreeEntry<T> deserialize(TreeEntry<T> node, List<String> desList){
if (desList.size() == 0){
return null;
}
String s = desList.remove(0); // efficient operation O(1)
if (s.equals("NULL")){
return null;
}
Integer sInt = Integer.parseInt(s);
node = new TreeEntry<T>((T)sInt);
node.left = deserialize(node.left, desList);
node.right = deserialize(node.right, desList);
return node;
}
public static void main(String[] args) {
/*
* 1
* / \
* 2 3
* /
* 4
*
*/
SerDesBinTree<Integer> tree = new SerDesBinTree<>();
tree.root = new TreeEntry<Integer>(1);
tree.root.left = new TreeEntry<Integer>(2);
tree.root.right = new TreeEntry<Integer>(3);
tree.root.right.left = new TreeEntry<Integer>(4);
//tree.traverseInOrder();
tree.serialize();
//System.out.println(tree.serSB);
tree.root = null;
//tree.traverseInOrder();
tree.root = tree.deserialize(tree.root);
//tree.traverseInOrder();
// deserialize into a new tree
SerDesBinTree<Integer> newTree = new SerDesBinTree<>();
newTree.root = tree.deserialize(newTree.root);
newTree.traverseInOrder();
}
}
これがPythonの遅い答えです。 （深さ優先）プレオーダーシリアル化を使用し、stringsのリストを返します。逆シリアル化はツリーを返します。
class Node:
def __init__(self, val, left=None, right=None):
self.val = val
self.left = left
self.right = right
# This method serializes the tree into a string
def serialize(root):
vals = []
def encode(node):
vals.append(str(node.val))
if node.left is not None:
encode(node.left)
else:
vals.append("L")
if node.right is not None:
encode(node.right)
else:
vals.append("R")
encode(root)
print(vals)
return vals
# This method deserializes the string back into the tree
def deserialize(string_list):
def create_a_tree(sub_list):
if sub_list[0] == 'L' or sub_list[0] == 'R':
del sub_list[0]
return
parent = Node(sub_list[0])
del sub_list[0]
parent.left = create_a_tree(sub_list)
parent.right = create_a_tree(sub_list)
return parent
if len(string_list) != 0:
root_node = create_a_tree(string_list)
else:
print("ERROR - empty string!")
return 0
return root_node
テストする：
tree1 = Node('root', Node('left'), Node('right'))
t = deserialize(serialize(tree1))
print(str(t.right.val))
最善の方法は、センチネルとして特殊文字（前述のコメントの＃のような）を使用することです。空間の複雑さと時間の複雑さの両方において、インオーダートラバーサル配列とプリオーダー/ポストオーダートラバーサル配列を構築するよりも優れています。また、実装もはるかに簡単です。
リンクされたリストは、ツリーを再構築するためにconst要素のアクセス時間を持っているので、ここでは適していません
インオーダートラバーサルを実行し、ルートキーとすべてのノードキーをstd :: listまたはツリーをフラット化する他の任意のコンテナーに配置するのはどうですか。次に、boostライブラリを使用して、選択したstd :: listまたはコンテナーをシリアル化します。
逆は簡単で、バイナリツリーへの標準の挿入を使用してツリーを再構築します。これは非常に大きなツリーでは完全に効率的ではないかもしれませんが、ツリーをstd :: listに変換するランタイムは最大でもO(n)）であり、ツリーを再構築するにはO（log n）ですせいぜい。
データベースをJavaからC++に変換しているときに、c ++でコーディングしたツリーをシリアル化するためにこれを実行しようとしています。
私は予約購入を使用していませんが、BFSを使用しています。これは leetcode からの質問です
予約購入を使用する場合、大多数の人々の実装は正しくありません。期待される結果は
"[1,2,3、null、null、4,5]"ですが、代わりに大多数の人が "[1,2,3、null、null、4,5、null、null]"と出力します。レベルを数えません。
これが正しい結果の実装です。
class Node(object):
def __init__(self,data):
self.left = None
self.right = None
self.data = data
def serialize(root):
queue = [(root,0)]
result = []
max_level_with_value = 0
while queue:
(node,l) = queue.pop(0)
if node:
result.append((node.data,l))
queue.extend([(node.left,l+1),
(node.right,l+1)
])
max_level_with_value = max(max_level_with_value,l)
else:
result.append(('null',l))
filter_redundant(result,max_level_with_value)
def filter_redundant(result,max_level_with_value):
for v,l in result:
if l<= max_level_with_value:
print(v)
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.right.left = Node(4)
root.right.right = Node(5)
serialize(root)