从下到上遍历任何深度的嵌套层次结构

Question

Take a nested recursive JSON snippet like this that can go on to any depth:

{
   "Id": null,
   "Foos": [
      {
         "FooId": 1,
         "FooName": "ABC",
         "Foos": [
            {
               "FooId": 2,
               "FooName": "DEF",
               "Foos": null
            },
            {
               "FooId": 3,
               "FooName": "GHI",
               "Foos": [
                  {
                     "FooId": 4,
                     "FooName": "JKL",
                     "Foos": null
                  },
                  {
                     "FooId": 5,
                     "FooName": "MNO",
                     "Foos": [
                        {
                           "FooId": 6,
                           "FooName": "PQR",
                           "Foos": null
                        },
                        {
                           "FooId": 7,
                           "FooName": "STU",
                           "Foos": null
                        }
                     ]
                  }
               ]
            }
         ]
      }
   ]
}

Using JSON.NET I can map that into a structure like this:

public class Root {
    public string Id { get; set; }
    public List<Foo> Foos { get; set; }
}

public class Foo {
    public int FooId { get; set; }
    public string FooName { get; set; }
    public List<Foo> Foos { get; set; }
}

so far so good...but now I need to work from the bottom of the hierarchy upward (starting with the children at FooId=5) and then working my way back up to the root. How do I tackle this efficiently?

Answer 1

It's unclear from your question whether you want a postorder (depth-first) traversal, or a reverse level traversal (breadth-first, reversed). Assuming you want postorder, the algorithm is straightforward:

public static IEnumerable<T> Postorder<T>(
  this IEnumerable<T> nodes,
  Func<T, IEnumerable<T>> children)
{
  foreach(T node in nodes)
  {
    foreach(T descendant in children(node).Postorder(children))
      yield return descendant;
    yield return node;
  }
}

Every node is yielded only after all of its descendants, so this is a postorder traversal.

That's reasonably efficient if the tree is shallow, but you say you wish to solve the problem for a tree of "any depth". This approach will only work efficiently for trees of depths up to a few dozen levels because it is O(nd) where n is the total number of nodes and d is the average depth; the average depth depends on the branching factor, and so could be as low as 1 or as high as n, making this a potentially quadradic algorithm.

Moreover, since it uses O(dmax) stack space where dmax is the maximum depth, we can blow the call stack.

Thus: if you have hundreds or thousands of levels, use the explicit stack technique.

Exercise : Rewrite my algorithm to use an explicit stack rather than using the call stack as an implicit stack.

But you said you need trees of any depth . What if there are billions, or trillions of nodes in the tree, billions or trillions deep? In that case you'll need to go with an external memory solution, and I would recommend building a custom storage system dedicated to this problem; do some research on at-scale graph databases, which can solve this sort of problem.

Anyways, now that you have the general solution, your specific solution is straightforward:

var ids = root.Foos
              .Postorder(f => f.Foos)
              .Select(f => f.FooId)
              .ToList();

or whatever.