LAMBDA 或 LINQ 中的分层 Max

Question

我有一个构建版本列表

List<int[]> BuildVersions;

如何找到最后的构建版本。

构建版本，例如

100.1.2.3
101.12.3.2
101.12.3.3

更新：表达式必须检查第一个数字，然后检查第二个数字，然后检查第三个数字，然后检查最后一个数字

Answer 1

int[] maxVersion = buildVersions.OrderByDescending(v => v[0])
                                .ThenByDescending(v => v[1])
                                .ThenByDescending(v => v[2])
                                .FirstOrDefault();

或者更通用的解决方案如下

T[] HierarchicalMax<T>(IEnumerable<T[]> items)
        {
            var length = items.Min(v => v.Length);
            IEnumerable<T[]> result = items;

            for (int i = 0; i < length; i++)
            {
                int offset = i;
                result = result.OrderByDescending(v => v[offset]);
            }

            T[] max = result.FirstOrDefault();

            return max;
        }

Answer 2

如果我理解正确的话，你有一个整数数组列表，并且你想确定其中某处的最高整数。

那会是这样的：

var max = BuildVersions.Max(x => x.Max(y => y));

Answer 3

效率有点低，因为它每次都会找到当前过滤版本集的最小长度。可以用时间来换取空间，但代价是使代码复杂化。假设 1.1 大于 1.1.1。

for (int versionPart = 0; versionPart < versions.Min(v => v.Length); versionPart += 1) {
    versions = versions.MaxValues(version => version[versionPart]);
}
var maxVersion = versions.FirstOrDefault();

使用扩展方法：

public static IEnumerable<T> MaxItems<T>(this IEnumerable<T> list, Func<T, int> selector) {  
    var enumerator = list.GetEnumerator();  

    if (!enumerator.MoveNext()) {  
        return Enumerable.Empty<T>();  
    }  

    var maxItem = enumerator.Current;  
    List<T> maxItems = new List<T>() { maxItem };  
    int maxValue = selector(maxItem);  

    while (enumerator.MoveNext()) {  
        var item = enumerator.Current;  
        var value = selector(item);  

        if (value > maxValue) {  
            maxValue = value;  
            maxItems = new List<T>() { item };  
        } else if (value == maxValue) {  
            maxItems.Add(item);  
        }  
    }  

    return maxItems;  
}

Answer 4

你有 int 数组的列表吗？

如果不，

int maxValue=BuildVersions.Max();