C# 在C中不使用递归，展平本身具有N个深度列表的列表项# 我想

在

C

中的单个列表中对N个深度项目进行排序。每个项目本身都有一个N深度列表。模型如下所示

TestModel model = new TestModel
        {
            Name = "Model",
            Nested = new List<TestModel>
            {
                new TestModel {
                    Name = "T1"
                },
                new TestModel {
                    Name = "T2"
                },
                new TestModel {
                    Name = "T3"
                },
                new TestModel {
                    Name = "T4-Nested01",
                    Nested = new List<TestModel> {
                        new TestModel {
                            Name = "T4-Nested01-T1",
                        },
                        new TestModel {
                            Name = "T4-Nested01-T2-Nested02",
                            Nested = new List<TestModel> {
                                new TestModel {
                                    Name = "T4-Nested01-T2-Nested02-T1-Nested03",
                                    Nested = new List<TestModel> {
                                        new TestModel {
                                            Name = "T4-Nested01-T2-Nested02-T1-Nested03-T1"
                                        },
                                        new TestModel {
                                            Name = "T4-Nested01-T2-Nested02-T1-Nested03-T2"
                                        },
                                        new TestModel {
                                            Name = "T4-Nested01-T2-Nested02-T1-Nested03-T3"
                                        }
                                    }
                                },
                                new TestModel {
                                    Name = "T4-Nested01-T2-Nested02-T2"                                        
                                },
                                new TestModel {
                                    Name = "T4-Nested01-T2-Nested02-T3"                                        
                                }
                            }
                        },
                        new TestModel {
                            Name = "Nested01-T2",
                        },
                        new TestModel {
                            Name = "Nested01-T3"
                        }
                    }
                }
            }
        };

        // model looks like this.
        // ㄴ Name = "Model"
        // ㄴ Nested Count 4
            // ㄴ [0] TestModel T1
            // ㄴ [1] TestModel T2
            // ㄴ [2] TestModel T3
            // ㄴ [3] TestModel T4
                // ㄴ Name = "T4-Nested01"
                // ㄴ Nested Count 4
                    // ㄴ [0] TestModel T4-Nested01-T1
                    // ㄴ [1] TestModel T4-Nested01-T2
                        // ㄴ Name = "T4-Nested01-T2-Nested02"
                        // ㄴ Nested Count 3
                            // [0] TestModel T4-Nested01-T2-Nested02-T1
                                // ㄴ Name = "T4-Nested01-T2-Nested02-T1-Nested03"
                                // ㄴ Nested Count 3
                                    // [0] TestModel T4-Nested01-T2-Nested02-T1-Nested03-T1
                                    // [1] TestModel T4-Nested01-T2-Nested02-T1-Nested03-T2
                                    // [2] TestModel T4-Nested01-T2-Nested02-T1-Nested03-T3
                                // [1] TestModel T4-Nested01-T2-Nested02-T2
                                // [2] TestModel T4-Nested01-T2-Nested02-T3
                    // ㄴ [2] TestModel
                    // ㄴ [3] TestModel

TestModel=newtestmodel
{
Name=“Model”，
嵌套=新列表
{
新测试模型{
Name=“T1”
},
新测试模型{
Name=“T2”
},
新测试模型{
Name=“T3”
},
新测试模型{
Name=“T4-Nested01”，
嵌套=新列表{
新测试模型{
Name=“T4-Nested01-T1”，
},
新测试模型{
Name=“T4-Nested01-T2-Nested02”，
嵌套=新列表{
新测试模型{
Name=“T4-Nested01-T2-Nested02-T1-Nested03”，
嵌套=新列表{
新测试模型{
Name=“T4-Nested01-T2-Nested02-T1-Nested03-T1”
},
新测试模型{
Name=“T4-Nested01-T2-Nested02-T1-Nested03-T2”
},
新测试模型{
Name=“T4-Nested01-T2-Nested02-T1-Nested03-T3”
}
}
},
新测试模型{
Name=“T4-Nested01-T2-Nested02-T2”
},
新测试模型{
Name=“T4-Nested01-T2-Nested02-T3”
}
}
},
新测试模型{
Name=“Nested01-T2”，
},
新测试模型{
Name=“Nested01-T3”
}
}
}
}
};
//模型看起来像这样。
// ㄴ Name=“Model”
// ㄴ 嵌套计数4
// ㄴ [0]测试模型T1
// ㄴ [1] 测试模型T2
// ㄴ [2] 测试模型T3
// ㄴ [3] 测试模型T4
// ㄴ Name=“T4-Nested01”
// ㄴ 嵌套计数4
// ㄴ [0]测试模型T4-Nested01-T1
// ㄴ [1] 测试模型T4-Nested01-T2
// ㄴ Name=“T4-Nested01-T2-Nested02”
// ㄴ 嵌套计数3
//[0]测试模型T4-Nested01-T2-Nested02-T1
// ㄴ Name=“T4-Nested01-T2-Nested02-T1-Nested03”
// ㄴ 嵌套计数3
//[0]测试模型T4-Nested01-T2-Nested02-T1-Nested03-T1
//[1]测试模型T4-Nested01-T2-Nested02-T1-Nested03-T2
//[2]测试模型T4-Nested01-T2-Nested02-T1-Nested03-T3
//[1]测试模型T4-Nested01-T2-Nested02-T2
//[2]测试模型T4-Nested01-T2-Nested02-T3
// ㄴ [2] 测试模型
// ㄴ [3] 测试模型

我需要 一个单一的列表，使通过排序列表中的某些属性搜索特定元素变得更容易。我已经有了一个递归算法来实现这个目标。但我想使用非递归的解决方案

问题:

我应该使用哪些非递归算法来获得最佳性能

最简单的代码应该使用哪些数据结构

---

给我一个想法就足够了，或者如果你能为我调整一个替代算法，我也会非常感激。

当你使用递归来迭代一个图时，看起来你没有使用任何数据结构来执行遍历，但实际上你使用的是隐式/固有的数据结构：堆栈。因此，要在不递归的情况下执行相同类型的遍历，就需要一个堆栈

在C#中，您可以使用堆栈、“yield return”关键字和委托创建一个类似linq的扩展方法，该方法将以非常方便和可重用的方式执行此图遍历。实施的大致概述如下：

public static IEnumerable<T> Flatten<T>(this T root, Func<T, IEnumerable<T>> selector)
{
    var stack = new Stack<T>();
    stack.Push(root);
    while(stack.Count > 0)
    {
        var current = stack.Pop();
        yield return current;
        foreach(var child in selector(current))
        {
            stack.Push(child);
        }
    }
}

您需要添加一些空检查和可选检查以防止无限循环（如果图形中的子级包含祖先，则此算法将陷入无限循环，而递归算法将堆栈溢出）

---

这种类型的图遍历称为“深度优先”。只需将堆栈换成队列，就可以实现“宽度优先”版本。

当使用递归迭代图形时，似乎没有使用任何数据结构来执行遍历，但实际上使用的是隐式/固有的数据结构：堆栈。因此，要在不递归的情况下执行相同类型的遍历，就需要一个堆栈

在C#中，您可以使用堆栈、“yield return”关键字和委托创建一个类似linq的扩展方法，该方法将以非常方便和可重用的方式执行此图遍历。实施的大致概述如下：

public static IEnumerable<T> Flatten<T>(this T root, Func<T, IEnumerable<T>> selector)
{
    var stack = new Stack<T>();
    stack.Push(root);
    while(stack.Count > 0)
    {
        var current = stack.Pop();
        yield return current;
        foreach(var child in selector(current))
        {
            stack.Push(child);
        }
    }
}

您需要添加一些空检查和可选的检查，以防止无限循环（如果图形中的子对象包含