如何在c#中排序这个站点url列表?

我的第一个想法是按字符串的长度排序…但后来我想到了一个这样的列表，其中可能包括诸如短名称的别名之类的东西:

<>之前/longsitename//一个/a/b/c//一个/a/b//otherlongsitename/之前

…我认为更好的选择是先按级别分隔符的数量排序:

IEnumerable<string> SortURLs(IEnumerable<string> urls)
{
    return urls.OrderBy(s => s.Count(c => c == '/')).ThenBy(s => s);
}

然后我又想了一下，我在你的问题中看到了这句话:

如果/node2不存在，我无法创建/node2/sub-node1

啊哈!分段的顺序或分段内的顺序并不重要，只要子节点总是列在父节点之后即可。考虑到这一点，我最初的想法是可以的，仅按字符串的长度排序应该很好:

IEnumerable<string> SortURLs(IEnumerable<string> urls)
{
    return urls.OrderBy(s => s.Length);
}

这让我终于想知道为什么我关心的长度?如果我只是对字符串排序，不管长度如何，开头相同的字符串总是先对较短的字符串排序。因此，最后:

IEnumerable<string> SortURLs(IEnumerable<string> urls)
{
    return urls.OrderBy(s => s);
}

我将保留第一个示例，因为在将来某个时候，如果您需要更多的词法或逻辑排序顺序，它可能会很有用。

是否有一个干净的方法来做到这一点?

只需使用标准字符串排序对URI列表进行排序就可以得到所需的内容。一般来说，在字符串排序中，"a"会排在"aa"之前，所以"/node1"应该排在"/node1/子节点"之前。

例如:

List<string> test = new List<string> { "/node1/sub-node1", "/node2/sub-node1", "/node1",  "/node2"  };
foreach(var uri in test.OrderBy(s => s))
   Console.WriteLine(uri);

这将打印:

/node1
/node1/sub-node1
/node2
/node2/sub-node1

也许这对你有用:

var nodes = new[] { "/node1", "/node1/sub-node1", "/node2", "/node2/sub-node1" };
var orderedNodes = nodes
    .Select(n => new { Levels = Path.GetFullPath(n).Split('''').Length, Node = n })
    .OrderBy(p => p.Levels).ThenBy(p => p.Node);

结果:

foreach(var nodeInfo in orderedNodes)
{
    Console.WriteLine("Path:{0} Depth:{1}", nodeInfo.Node, nodeInfo.Levels);
}
Path:/node1 Depth:2
Path:/node2 Depth:2
Path:/node1/sub-node1 Depth:3
Path:/node2/sub-node1 Depth:3

var values = new string[]{"/node1", "/node1/sub-node1" ,"/node2", "/node2/sub-node1"};
foreach(var val in values.OrderBy(e => e))
{
    Console.WriteLine(val);
}

最好是使用自然排序，因为您的字符串混合在字符串和数字之间。因为如果你使用其他排序方法或技术比如这个例子:

List<string> test = new List<string> { "/node1/sub-node1" ,"/node13","/node10","/node2/sub-node1", "/node1", "/node2" };

的输出将是:

/node1
/node1/sub-node1
/node10
/node13
/node2
/node2/sub-node1

没有排序。

你可以看看这个实现

如果您的意思是在所有第二级节点之前需要所有第一级节点，则按斜杠的数量排序/:

string[] array = {"/node1","/node1/sub-node1", "/node2", "/node2/sub-node1"};
array = array.OrderBy(s => s.Count(c => c == '/')).ToArray();
foreach(string s in array)
    System.Console.WriteLine(s);

结果:

/node1
/node2
/node1/sub-node1
/node2/sub-node1

如果你只需要父节点在子节点之前，没有比

更简单的了

Array.Sort(array);

结果:

/node1
/node1/sub-node1
/node2
/node2/sub-node1

递归实际上正是你应该使用的，因为它最容易用树结构来表示。

public class PathNode {
    public readonly string Name;
    private readonly IDictionary<string, PathNode> _children;
    public PathNode(string name) {
        Name = name;
        _children = new Dictionary<string, PathNode>(StringComparer.InvariantCultureIgnoreCase);
    }
    public PathNode AddChild(string name) {
        PathNode child;
        if (_children.TryGetValue(name, out child)) {
            return child;
        }
        child = new PathNode(name);
        _children.Add(name, child);
        return child;
    }
    public void Traverse(Action<PathNode> action) {
        action(this);
        foreach (var pathNode in _children.OrderBy(kvp => kvp.Key)) {
            pathNode.Value.Traverse(action);
        }
    }
}

你可以这样使用:

var root = new PathNode(String.Empty);
var links = new[] { "/node1/sub-node1", "/node1", "/node2/sub-node-2", "/node2", "/node2/sub-node-1" };
foreach (var link in links) {
    if (String.IsNullOrWhiteSpace(link)) {
        continue;
    }
    var node = root;
    var lastIndex = link.IndexOf("/", StringComparison.InvariantCultureIgnoreCase);
    if (lastIndex < 0) {
        node.AddChild(link);
        continue;
    }
    while (lastIndex >= 0) {
        lastIndex = link.IndexOf("/", lastIndex + 1, StringComparison.InvariantCultureIgnoreCase);
        node = node.AddChild(lastIndex > 0 
            ? link.Substring(0, lastIndex) // Still inside the link 
            : link // No more slashies
        );
    }
}
var orderedLinks = new List<string>();
root.Traverse(pn => orderedLinks.Add(pn.Name));
foreach (var orderedLink in orderedLinks.Where(l => !String.IsNullOrWhiteSpace(l))) {
    Console.Out.WriteLine(orderedLink);
}

应该打印:

/node1
/node1/sub-node1
/node2
/node2/sub-node-1
/node2/sub-node-2