wake-up-neo.com

So können Sie den binären Baum serialisieren

Ich ging heute zu einem Interview, in dem ich gebeten wurde, einen binären Baum zu serialisieren. Ich habe einen Array-basierten Ansatz implementiert, bei dem sich die Kinder des Knotens i (Nummerierung in Durchlauf auf Ebene der Reihenfolge) beim 2 * i-Index für das linke Kind und 2 * i + 1 beim rechten Kind befanden. Der Interviewer schien mehr oder weniger zufrieden zu sein, aber ich frage mich, was Serialisierung genau bedeutet. Handelt es sich speziell auf das Abflachen des Baums zum Schreiben auf die Festplatte, oder würde das Serialisieren eines Baums auch umfassen, den Baum beispielsweise in eine verknüpfte Liste umzuwandeln. Wie könnten wir den Baum in eine (doppelt) verknüpfte Liste bringen und dann rekonstruieren? Können Sie die genaue Struktur des Baums aus der verknüpften Liste wiederherstellen?

27
worker1138

Alle diese Artikel sprechen meistens über den Serialisierungsteil. Der Deserialisierungsteil ist in einem Durchgang etwas schwierig.

Ich habe auch eine effiziente Lösung zur Deserialisierung implementiert. 

Problem: Serialisieren und deserialisieren Sie einen binären Baum mit positiven Zahlen.

Serialisierungsteil:

  1. Verwenden Sie 0, um Null darzustellen.
  2. Serialisieren Sie in eine Liste ganzer Zahlen mit Hilfe der Vorbestellung.

Deserialisierungsteil:

  1. Übernimmt eine Liste ganzer Zahlen und verwendet zur Deserialisierung eine rekursive Hilfsmethode.
  2. Der rekursive Deserializer gibt ein Paar (BTNode-Knoten, int nextIndexToRead) zurück, wobei der Knoten ein Baumknoten ist, der bisher erstellt wurde, und nextIndexToRead die Position der nächsten zu lesenden Nummer in der serialisierten Liste der Nummern.

Unten ist der Code in 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;
    }
}
13
AbhishekPrateek

Ansatz 1: Führen Sie sowohl Inorder- als auch Preorder-Durchlauf durch, um die Baumdaten zu searialisieren. Bei der Deserialisierung verwenden Sie Vorbestellen und führen Sie BST in Inorder aus, um den Baum ordnungsgemäß zu bilden.

Sie brauchen beides, weil A -> B -> C als Vorbestellung dargestellt werden kann, obwohl die Struktur unterschiedlich sein kann. 

Ansatz 2: Verwenden Sie # als Sentinel, wenn das linke oder rechte Kind null ist.

7
Ketan Thakkar

Bei der Vorbestellung wird der binäre Baum serialisiert. Verwenden Sie die gleiche Vorbestellung, um den Baum zu deserialisieren. Seien Sie vorsichtig mit den Edge-Fällen. Hier werden Nullknoten durch "#" dargestellt. 

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;
    } 
5
sreeprasad

Hier ist eine späte Antwort in Python. Sie verwendet die Vorbestellungsserialisierung (Tiefe zuerst) und gibt eine Liste von strings zurück. Deserialisierung gibt den Baum zurück.

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

Zu testen:

tree1 = Node('root', Node('left'), Node('right'))
t = deserialize(serialize(tree1))
print(str(t.right.val))
0
Bn.F76

Der beste Weg ist, ein spezielles Zeichen (wie # als vorherigen Kommentar) als Sentinel zu verwenden. Es ist besser als ein Inorder-Traversal-Array und ein Preorder/Postorder-Traversal-Array zu erstellen, sowohl in Bezug auf die Raumkomplexität als auch auf Zeitebene. es ist auch viel einfacher zu implementieren.

Die verknüpfte Liste ist hier nicht geeignet, da Sie zum Wiederherstellen des Baums besser auf die Zugriffszeit für const-Elemente zugreifen können

0
Haitao

Ich habe versucht, den Gist davon zu bekommen. Hier ist meine Java-Implementierung. Wie bereits erwähnt, ist dies ein binärer Baum, keine BST. Für die Serialisierung scheint eine Durchsuchung vor der Bestellung einfacher zu sein (zu einer Zeichenfolge mit "NULL" für Nullknoten). Bitte überprüfen Sie den Code mit einem vollständigen Beispiel für Rekursionsaufrufe. Zur Deserialisierung wird der String in eine LinkedList konvertiert, wobei remove (0) das oberste Element in einer O(1) - Laufzeit abruft. Bitte beachten Sie auch ein vollständiges Beispiel in den Kommentaren des Codes zur Deserialisierung. Ich hoffe, das hilft jemandem, weniger zu kämpfen als ich:) .__ Die Gesamtlaufzeit für jede Methode (serialisieren und deserialisieren) ist die gleiche Laufzeit für binäres Baumdurchlaufen, dh O(n), wobei n ist die Anzahl der Knoten (Einträge) im Baum

import Java.util.LinkedList; import Java.util.List;

öffentliche Klasse 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();


}

}

0
Khaled Alnaami

Wie wäre es mit einem In-Order-Traversal und dem Einfügen des Root-Schlüssels und aller Knotenschlüssel in eine std :: -Liste oder einen anderen Container Ihrer Wahl, der den Baum flacher macht. Dann serialisieren Sie einfach die std :: list oder den Container Ihrer Wahl mithilfe der Boost-Bibliothek.

Der umgekehrte Vorgang ist einfach. Erstellen Sie dann den Baum mithilfe der Standardeinfügung in einen Binärbaum neu. Dies ist für einen sehr großen Baum möglicherweise nicht ganz effizient, aber die Laufzeit zum Konvertieren des Baums in eine std :: list ist höchstens O(n) und zum Wiederherstellen des Baums höchstens O (log n).

Ich bin dabei, einen Baum zu serialisieren, den ich gerade in C++ codiert habe, während ich meine Datenbank von Java nach C++ konvertiere.

0
user633658