Question

我进行递归以在List中找到具有多个子节点的长值，这些子节点也可以有子节点。

以下方法：

public TaxonomyData getTaxonomyData(long taxId, List<TaxonomyData> TaxonomyTree, TaxonomyData output)
{
    //find taxid in the taxonomy tree list and return the taxonomydata

    foreach (TaxonomyData td in TaxonomyTree)
    {
        if (td.TaxonomyId == taxId)
        {
                output = td;
                //return td; => when doing a return here means I already found a match so it is not necessary to do all the recursion.
        }
        else if (td.Taxonomy.Length > 0)
        {
            getTaxonomyData(taxId, td.Taxonomy.ToList(), output);
        }
    }

    return output;
}

当我return td;（见注释行）我的整个递归停止时是否可能？

由于

Answer 1

我怀疑你想要这样的东西：

public TaxonomyData GetTaxonomyData(long taxId, IEnumerable<TaxonomyData> tree)
{
    foreach (TaxonomyData td in tree)
    {
        if (td.TaxonomyId == taxId)
        {
            return td;
        }
        else
        {
            // See if it's in the subtree of td
            TaxonomyData data = GetTaxonomyData(taxId, td.Taxonomy);
            if (data != null)
            {
                return data;
            }
        }
    }
    // Haven't found it anywhere in this tree
    return null;
}

每个return只返回一个级别，但通过检查else子句中的返回值，当我们找到正确的值时，我们可以一直向上返回。

如果找不到，则返回给调用者的最终结果将是空引用。

请注意，我已删除了“输出”参数，该参数由于不是ref参数而无法生效，并且不如只是使用返回值。

Answer 2

我提出了一个linq扩展解决方案，可能比较慢，但你去了..

public static class Ext
{
    public static T SingleOrDefault<T>(this IEnumerable<T> enumerable,Func<T,bool> predicate, Func<T,T> defaultSelector)
        where T : class
    {   
        return enumerable.SingleOrDefault(predicate) ?? enumerable.SkipWhile<T>(t=>defaultSelector(t) == null).Select(defaultSelector).SingleOrDefault();
    } 

    public static TaxonomyData Get(this IEnumerable<TaxonomyData> tree, int taxId)
    {
        return tree.SingleOrDefault(t=> t.TaxonomyId == taxId,t=>t.Taxonomy.Get(taxId));
    }
}

返回时，完全停止递归

2 个答案: