在JavaScript中反序列化二进制搜索树

Question

The input is a pre-order serialized BST with null values. The values have been read into an array with integers and null values.

Sample input

[ 6, 3, null, null, 8, null, 9, null, null ]

Wanted output

{ _root: 
    { value: 6,
      left:  { value: 3, 
               left: null,  
               right: null },
      right: { value: 8,  
               left: null,  
               right: { value: 9,  
                        left: null,   
                        right: null } } } }

Here is the basic interface for the BST:

function BinarySearchTree() {
    this._root = null;
}

BinarySearchTree.prototype = {

    //restore constructor
    constructor: BinarySearchTree,

    insert: function(value) {

        //create a new item object, place data in
        var node = {
                value: value,
                left: null,
                right: null
            },

            current;

        // more code (works, but omitted for this question)
    }
};

How can we deserialize the above input so we end up with a BinarySearchTree? Would this be a recursive pre-order traversal along these lines?

function deserialize(arr) {
    var result = new BinarySearchTree();
    result._root = arr[0];

    if (arr[1] === null) {
        result._root.left = null;
    }

    if () {
        return null;
    }

    node.left = deserialize(arr);
    node.right = deserialize(arr);

    return result;
}

Answer 1

So I assume that the input structure will be Node 1, left child node 1, left grandchild node 1, ... right child node 1, right grandchild node 1, ...

We can maintain a stack to build the tree, which help to retrieve the higher level easily, (or we can add a pointer to each node's parent).

Java code:

void builTree(Integer input){

    Node root = new Node(input[0]);
    Node cur = root;


    for(int i = 1; i < input.length; i++){
        if(cur.count <=1){
          cur = update(cur,input[i]);
        }else{
           while(cur.count == 2){//This while loop may not necessary
               cur = cur.parent;   
           }   
          cur = update(cur, s, input[i]);    
        }          
    }
}

Node update(Node node,  Integer input){
     if(node.count == 0){
       node.left = new Node(input);
       node.left.parent = node;
       node.count++;
       if(input != null){
          return node.left;
       }
     }else if(node.count == 1){           
       node.right = new Node(input);
       node.right.parent = node;
       node.count++;
       if(input != null){
          return node.right;
       }
     }
     return node;
}

class Node{
   int value , count;//variable count will tell whether a node is full or not
   Node left, right, parent;
}