C# LAMBDA或LINQ中的分层最大值

我有一个构建版本列表

List<int[]> BuildVersions;

---

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

有int数组的列表吗

如果没有,

int maxValue=BuildVersions.Max();

---

你有int数组的列表吗

如果没有,

int maxValue=BuildVersions.Max();

---

如果我理解正确的话，您有一个int数组列表，您想确定其中某个地方的最高int

可能是这样的：

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

---

如果我理解正确的话，您有一个int数组列表，您想确定其中某个地方的最高int

可能是这样的：

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

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

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;
        }

T[]层次结构最大值（IEnumerable项）
{
变量长度=items.Min（v=>v.length）；
IEnumerable结果=项目；
for（int i=0；iv[offset]）；
}
T[]max=result.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;
        }

T[]层次结构最大值（IEnumerable项）
{
变量长度=items.Min（v=>v.length）；
IEnumerable结果=项目；
for（int i=0；iv[offset]）；
}
T[]max=result.FirstOrDefault（）；
返回最大值；
}

效率有点低，因为它每次都会找到当前筛选版本集的最小长度。这样做的时间可以用来换取空间，而代价是代码复杂化。它假定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();

for（int versionPart=0；versionPartv.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;  
}

公共静态IEnumerable MaxItems（此IEnumerable列表，函数选择器）{
var枚举器=list.GetEnumerator（）；
如果（！enumerator.MoveNext（））{
返回可枚举的.Empty（）；
}  
var maxItem=枚举数.Current；
List maxItems=新列表（）{maxItem}；
int maxValue=选择器（maxItem）；
while（枚举数.MoveNext（））{
变量项=枚举数。当前；
var值=选择器（项目）；
如果（值>最大值）{
最大值=最大值；
maxItems=new List（）{item}；
}如果（value==maxValue）{
添加（项目）；
}  
}  
归还物品；
}

效率有点低，因为它每次都会找到当前筛选版本集的最小长度。这样做的时间可以用来换取空间，而代价是代码复杂化。它假定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();

for（int versionPart=0；versionPartv.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;  
}

公共静态IEnumerable MaxItems（此IEnumerable列表，函数选择器）{
var枚举器=list.GetEnumerator（）；
如果（！enumerator.MoveNext（））{
返回可枚举的.Empty（）；
}  
var maxItem=枚举数.Current；
List maxItems=新列表（）{maxItem}；
int maxValue=选择器（maxItem）；
while（枚举数.MoveNext（））{
变量项=枚举数。当前；
var值=选择器（项目）；
如果（值>最大值）{
最大值=最大值；
maxItems=new List（）{item}；
}如果（value==maxValue）{
添加（项目）；
}  
}  
归还物品；
}

请澄清您的问题。现在很难确定你的意思。在“上一个构建版本”下你是什么意思。“版本”有什么结构？提供一些样本数据，请澄清您的问题。现在很难确定你的意思。在“上一个构建版本”下你是什么意思。“版本”有什么结构？提供一些示例daataNo可能不是。表达式必须检查第一个数字，然后检查第二个，然后检查第三个，最后一个。这就是它的作用。它从已经是数组最大值的值列表中取出最大值。它取单个版本的最大值（10.12.11.9将返回12），然后按该值排序，这不起作用。按该值排序？我不这么认为。它是怎么分类的？啊哈，我看到这个问题现在被修改了。。。这和我想象的完全不同。不，也许不是。表达式必须检查第一个数字，然后是第二个，然后是第三个，最后一个。这就是它的作用。它从已经是数组最大值的值列表中取出最大值。它取单个版本的最大值（10.12.11.9将返回12），然后按该值排序，这不起作用。按该值排序？我不这么认为。它是怎么分类的？啊哈，我看到这个问题现在被修改了。。。这是一件完全不同于我想象的事情。就是这样。太棒了，兄弟。第二件真的太棒了。谢谢你为什么不为（int offset=0；offset？如果你有不同长度的版本，这是行不通的。例如，在[2.1.1,2.1.2,1.2]中，它可能会选择2.1.1。我不是闭包的一部分，因为需要一个局部变量。就是这样。很棒的兄弟。第二个真的很棒。谢谢为什么不只是为（int offset=0；offset做

？如果你有不同长度的版本，这不起作用。例如，对于[2.1.1,2.1.2,1.2]，它可能会选择2.1.1。i不是闭包的一部分，因为需要一个局部变量。他有一个int数组列表，不管它是什么（只是因为答案不起作用）-1他有一个int数组列表，不管它是什么（只是）