Question

我有一系列字符串：

"Alberton;Johannesburg"
"Allendale;Phoenix"
"Brackenhurst;Alberton"
"Cape Town;"
"Durban;"
"Johannesburg;"
"Mayville;Durban"
"Phoenix;Durban"
"Sandton;Johannesburg"

我希望以最快的方式构建一个层次结构，例如：

约翰内斯堡
- 艾伯
  - Brackenhurst
- 桑顿
开普敦
德班
- 菲尼克斯
  - Allandale
- 梅维尔

目前我已经嵌套了for循环和检查，但希望我能用一个LAMBDA查询实现这个目标吗？

上面提到的字符串在列表中。

Answer 1

您没有指定任何特定的数据结构，所以我只使用了一个名为Area的类，其中包含一个子类列表。此外，它有两行linq。也没有检查区域是否是2个独立父母的孩子，因为代码是。这是我使用的测试代码（等于注释之间的相关行）：

[TestFixture]
public class CitiesTest
{
    [Test]
    public void Test()
    {
        var strings = new List<string>
            {
                "Alberton;Johannesburg",
                "Allendale;Phoenix",
                "Brackenhurst;Alberton",
                "Cape Town;",
                "Durban;",
                "Johannesburg;",
                "Mayville;Durban",
                "Phoenix;Durban",
                "Sandton;Johannesburg"
            };

        //===================================================
        var allAreas = strings.SelectMany(x=>x.Split(';')).Where(x=>!string.IsNullOrWhiteSpace(x)).Distinct().ToDictionary(x=>x, x=>new Area{Name = x});

        strings.ForEach(area =>
            {
                var areas = area.Split(';');

                if (string.IsNullOrWhiteSpace(areas[1]))
                    return;

                var childArea = allAreas[areas[0]];
                if (!allAreas[areas[1]].Children.Contains(childArea))
                    allAreas[areas[1]].Children.Add(childArea);

                childArea.IsParent = false;
            });

        var result = allAreas.Select(x=>x.Value).Where(x => x.IsParent);
        //===================================================
    }

    public class Area
    {
        public string Name;
        public bool IsParent;
        public List<Area> Children { get; set; }

        public Area()
        {
            Children = new List<Area>();
            IsParent = true;
        }
    }
}

Answer 2

我准备了类似lambda的解决方案，但你应该考虑它是否比你现有的更具可读性/效率：

帮助程序扩展方法：

public static class ChildrenGroupExtensions
{
    public static List<CityInfo> GetChildren(this IEnumerable<IGrouping<string, City>> source, string parentName)
    {
        var cities = source.SingleOrDefault(g => g.Key == parentName);
        if (cities == null)
            return new List<CityInfo>();

        return cities.Select(c => new CityInfo { Name = c.Name, Children = source.GetChildren(c.Name) }).ToList();
    }
}

帮手类：

public class City
{
    public string Name { get; set; }
    public string Parent { get; set; }
}

public class CityInfo
{
    public string Name { get; set; }
    public List<CityInfo> Children { get; set; }
}

用法：

var groups = (from i in items
                let s = i.Split(new[] { ';' })
                select new City { Name = s[0], Parent = s[1] }).GroupBy(e => e.Parent);


var root = groups.GetChildren(string.Empty);

items <{1}}是List<string>

您可以使用简单的辅助方法查看结果：

private static void PrintTree(List<CityInfo> source, int level)
{
    if (source != null)
    {
        source.ForEach(c =>
        {
            Enumerable.Range(1, level).ToList().ForEach(i => Console.Write("\t"));
            Console.WriteLine(c.Name);
            PrintTree(c.Children, level + 1);
        });
    }
}

结果是：

Cape Town
Durban
        Mayville
        Phoenix
                Allendale
Johannesburg
        Alberton
                Brackenhurst
        Sandton

从字符串C＃构建层次结构

2 个答案: