Get the level of a hierarchy

algorithm, dataflow, hierarchy, javascript, sorting

Solution

A working example of the below code is on jsFiddle.

Index the tree by id and traverse it upwards, from each node, and count until you hit the root. By indexing first, we approach O(n) time complexity (depending on tree density). ****Updated to satisfy the sorting requirement, and allow exclusion of root node***:

function levelAndSort(data, startingLevel) {
    // indexes
    var indexed = {};        // the original values
    var nodeIndex = {};      // tree nodes
    var i;
    for (i = 0; i < data.length; i++) {
        var id = data[i].id;
        var node = {
            id: id,
            level: startingLevel,
            children: [],
            sorted: false
        };
        indexed[id] = data[i];
        nodeIndex[id] = node;
    }

    // populate tree
    for (i = 0; i < data.length; i++) {
        var node = nodeIndex[data[i].id];
        var pNode = node;
        var j;
        var nextId = indexed[pNode.id].parentId;
        for (j = 0; nextId in nodeIndex; j++) {
            pNode = nodeIndex[nextId];
            if (j == 0) {
                pNode.children.push(node.id);
            }
            node.level++;
            nextId = indexed[pNode.id].parentId;
        }
    }

    // extract nodes and sort-by-level
    var nodes = [];
    for (var key in nodeIndex) {
        nodes.push(nodeIndex[key]);
    }
    nodes.sort(function(a, b) {
        return a.level - b.level;
    });

    // refine the sort: group-by-siblings
    var retval = [];
    for (i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var parentId = indexed[node.id].parentId;
        if (parentId in indexed) {
            var pNode = nodeIndex[parentId];
            var j;
            for (j = 0; j < pNode.children.length; j++) {
                var child = nodeIndex[pNode.children[j]];
                if (!child.sorted) {
                    indexed[child.id].level = child.level;
                    retval.push(indexed[child.id]);
                    child.sorted = true;
                }
            }
        }
        else if (!node.sorted) {
            indexed[node.id].level = node.level;
            retval.push(indexed[node.id]);
            node.sorted = true;
        }
    }
    return retval;
}

Example:

// level 0 (root) excluded
var startingLevel = 1;
var someData = [
    {id : "id-1", parentId : "id-0"},
    {id : "id-2", parentId : "id-0"},
    {id : "id-3", parentId : "id-2"},
    {id : "id-4", parentId : "id-3"},
    {id : "id-5", parentId : "id-4"},
    {id : "id-6", parentId : "id-4"},
    {id : "id-7", parentId : "id-0"},
    {id : "id-8", parentId : "id-1"},
    {id : "id-9", parentId : "id-7"},
    {id : "id-10", parentId : "id-1"},
    {id : "id-11", parentId : "id-1"},
    {id : "id-12", parentId : "id-1"}
];
var outputArray = levelAndSort(someData, startingLevel);

Output:

Note

If you change the input order, the sort comes out a little different, but it's still correct (i.e., in level-order, grouped by sibling).

Problem

I have an array of objects, Where each object has an `id` and a `ParentId` property (so they can be arranged in trees). They are in no particular order. Please note that the `id`'s and `parentId`'s will not be integers, they will be strings (just wanted to have the sample code cleaner..) There is only one root: lets say its `id`:1 The data looks like so: ``` data = [ { id:"id-2", parentId:"id-3" }, { id:"id-4", parentId:"2" }, { id:"id-3", parentId:"id-4" }, { id:"id-5", parentId:"id-4" }, { id:"id-6", parentId:"id-1" }, { id:"id-7", parentId:"id-1" } // and so on... ] ``` I am looking for a efficient way to give each object a `level` property which should specify the nested level it is... They should then look like this: ``` data = [ { id:"id-2", parentId:"id-1", level:2 }, { id:"id-3", parentId:"id-4", level:5 }, { id:"id-4", parentId:"id-2", level:3 }, { id:"id-5", parentId:"id-4", level:5 }, { id:"id-6", parentId:"id-1", level:2 }, { id:"id-7", parentId:"id-3", level:4 } // and so on... ] ``` In short: I want that `level` to be added dynamically via looping thru the array and figuring out the hierarchy.. Additionally, (if posible) they should then be sorted according to there order, like for instance all objects `level:3`'s from the same parent should be next to each other, not that there should be siblings of the same parent next to each other rather then two cousins of level 3 next to each other.

Original source