Comment sérialiser L'arbre binaire
je suis allé à une entrevue aujourd'hui où on m'a demandé de sérialiser un arbre binaire. J'ai mis en place une approche basée sur un tableau où les enfants du noeud i (numérotés en ordre de niveau transversal) étaient à l'index 2*i pour l'enfant de gauche et 2*i + 1 pour l'enfant de droite. L'intervieweur semblait plus ou moins satisfait, mais je me demande ce que serialize signifie exactement? Se rapporte-t-il spécifiquement à aplatir l'arbre pour écrire sur le disque, ou serialiser un arbre inclurait aussi juste transformer l'arbre en une liste liée, par exemple. En outre, comment pourrions-nous aplatir l'arbre en une liste (doublement) liée, puis la reconstruire? Pouvez-vous recréer la structure exacte de l'arbre à partir de la liste chaînée?
6 réponses
tous ces articles parlent principalement de la partie de sérialisation. La partie désérialisation est un peu délicate à faire en un seul passage.
j'ai aussi mis en place une solution efficace pour la desérialisation.
problème: sérialiser et Desérialiser un arbre binaire contenant des nombres positifs.
la Sérialisation de la partie:
- utilisez 0 pour représenter null.
- Sérialize à la liste des entiers en utilisant preorder traversée.
Désérialisation partie:
- prend la liste des entiers et utilise la méthode d'aide récursive pour la desérialisation.
- Recursive deserializer retourne une paire (noeud de BTNode, int nextIndexToRead) où le noeud est le noeud d'arbre Construit jusqu'à présent, et nextIndexToRead est la position du prochain nombre à lire dans la liste sérialisée des nombres.
ci-dessous est le code en 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;
}
}
approche 1: Faire à la fois la traversée ordonnée et la traversée prédéfinie pour searialiser les données de l'arbre. Sur la désérialisation utilisez la précommande et faites la TSB sur Inorder pour former correctement l'arbre.
vous avez besoin des deux parce que A - > B- > C peut être représenté comme pré-ordre même si la structure peut être différente.
approche 2: Utilisez # comme une sentinelle où l'enfant de gauche ou de droite est nul.....
utilisation de l'arborescence binaire pre order traversal, serialize. Utilisez le même pré-ordre transversal pour désérialiser l'arbre. Soyez prudent sur les cas limites. Ici les noeuds Nuls sont représentés par"#"
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;
}
Que Diriez-vous d'effectuer une traversée dans l'ordre et de mettre la clé racine et toutes les clés de noeud dans un std::list ou un autre conteneur de votre choix qui aplatit l'arbre. Ensuite, il vous suffit de sérialiser la liste std::ou le conteneur de votre choix en utilisant la bibliothèque boost.
l'inverse est simple et puis reconstruire l'arbre en utilisant l'insertion standard dans un arbre binaire. Ceci peut ne pas être tout à fait efficace pour un arbre très grand mais runtime pour convertir l'arbre en un std:: list est O (n) au plus et pour reconstruire l'arbre est O (log n) au plus.
je suis sur le point de faire ceci pour sérialiser un arbre que je viens de coder en c++ alors que je suis en train de convertir ma base de données de Java en C++.
la meilleure façon est d'utiliser un omble spécial (comme # comme commentaire mentionné précédemment) comme sentinelle. C'est mieux que de construire un tableau transversal inorder et un tableau transversal preorder/postorder, à la fois dans la complexité de l'espace et dans la complexité du temps. il est également plus facile à mettre en œuvre.
Linked list n'est pas un bon ajustement ici car pour reconstruire l'arbre, vous avez intérêt à avoir le temps d'accès à l'élément const
j'ai essayé d'obtenir l'essentiel. Voici donc mon implémentation Java. Comme mentionné, c'est un arbre binaire pas un BST. Pour sérialiser, un pré-ordre transversal semble fonctionner plus facilement (vers une chaîne avec "NULL" pour les noeuds nuls). S'il vous plaît vérifier le code ci-dessous avec un exemple complet d'appels de récursion. Pour la deserialisation, la chaîne est convertie en une liste de liens où remove(0) obtient l'élément supérieur dans un temps D'exécution O(1). Voir aussi un exemple complet dans les commentaires du code pour la désérialisation. Espère que cela va aider quelqu'un lutte moins que je n'ai :) Le temps de fonctionnement global pour chaque méthode (serialize et deserialize) est le même temps de fonctionnement pour l'arbre binaire transversal, i.e., O( n) où n est le nombre de noeuds (entrées) dans l'arbre
import java.util.LinkedList; importer java.util.Liste;
public class 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();
}
}