Question

I am looking at alternatives to a deep search algorithm that I’ve been working on. My code is a bit too long to post here, but I’ve written a simplified version that captures the important aspects. First, I’ve created an object that I’ll call ‘BranchNode’ that holds a few values as well as an array of other ‘BranchNode’ objects.

class BranchNode : IComparable<BranchNode>
{
    public BranchNode(int depth, int parentValue, Random rnd)
    {
        _nodeDelta = rnd.Next(-100, 100);
        _depth = depth + 1;
        leafValue = parentValue + _nodeDelta;

        if (depth < 10)
        {
            int children = rnd.Next(1, 10);
            branchNodes = new BranchNode[children];
            for (int i = 0; i < children; i++)
            {
                branchNodes[i] = new BranchNode(_depth, leafValue, rnd);
            }
        }
    }

    public int CompareTo(BranchNode other)
    {
        return other.leafValue.CompareTo(this.leafValue);
    }


    private int _nodeDelta;
    public BranchNode[] branchNodes;
    private int _depth;
    public int leafValue;


}

In my actual program, I’m getting my data from elsewhere… but for this example, I’m just passing an instance of a Random object down the line that I’m using to generate values for each BranchNode… I’m also manually creating a depth of 10, whereas my actual data will have any number of generations.

As a quick explanation of my goals, _nodeDelta contains a value that is assigned to each BranchNode. Each instance also maintains a leafValue that is equal to current BranchNode’s _nodeDelta summed with the _nodeDeltas of all of it’s ancestors. I am trying to find the largest leafValue of a BranchNode with no children.

Currently, I am recursively transversing the heirarchy searching for BranchNodes whose child BranchNodes array is null (a.k.a: a ‘childless’ BranchNode), then comparing it’s leafValue to that of the current highest leafValue. If it’s larger, it becomes the benchmark and the search continues until it’s looked at all BranchNodes.

I can post my recursive search algorithm if it’d help, but it’s pretty standard, and is working fine. My issue is, as expected, that for larger heirarchies, my algorithm takes a long while to transverse the entier structure.

I was wondering if I had any other options that I could look into that may yield faster results… specificaly, I’ve been trying to wrap my head around linq, but I’m not even sure that it is built to do what I’m looking for, or if it’d be any faster. Are there other things that I should be looking into as well?

Answer 1

Maybe you want to look into an alternative data index structure: Here

It always depends on the work you are doing with the data, but if you assign a unique ID on each element that stores the hierarchical form, and creating an index of what you store, your optimization will make much more sense than micro-optimizing parts of what you do.

Also, this also lends itself a very different paradigm in search algorithms, that uses no recursion, but in the cost of additional memory for the IDs and possibly the index.