Ricostruzione di un albero dalle informazioni di profondità

È abbastanza semplice. Hai bisogno di un contenitore FIFO (stack) e di un nodo root.

Aggiungi sempre nuovi nodi come nodi del nodo frontale nello stack. Quando vedi una profondità maggiore rispetto al passato, aggiungi l'ultima nota aggiunta allo stack, prima di aggiungere il successivo. Quando vedi una profondità più piccola, pop dalla pila delta volte (di nuovo: prima di aggiungere il prossimo nodo). Non traccia la profondità attuale, è già tracciata per pila.

Pseudocodice:

root = new Node
stack = new Stack
stack.push(root)

for record in records
    delta = record.depth - (stack.size - 1)

    if delta > 0
        assert delta == 1
        stack.push(stack.front().last_child())

    while delta < 0
        stack.pop()
        delta++

    stack.front().add_child(record.node)

return root

Puoi capirlo meglio, se rappresenti la profondità come N rientri, dove N = profondità.

node #1, depth 0 // parent: none
    node #2, depth 1 // parent: #1
    node #3, depth 1 // parent: #1
        node #4, depth 2 // parent: #3
    node #5, depth 1 // parent: #1
        node #6, depth 2 // parent: #5

Ok, alcuni pseudocodice e brutti globali per una maggiore pigrizia:

var tree;
var position = 0;
var list = []; // to be filled with your list before you start;

process = function(depth, pos) {
  var nodes = [];
  while(list[pos + 1].depth >= depth) {
    pos = pos + 1;
    if(list[pos].depth == depth) {
      nodes.push({some_value: value, 
                  another_value: whatever,
                  children: null});
    else {
      nodes[nodes.length-1].children = process(depth + 1, pos);
    }
  };
  return nodes;
};

tree = process(0, 0);

Quindi, spero di non aver incasinato troppi dettagli, ma l'idea dovrebbe funzionare.