2

我有一个名为 entry 的对象。它在浮点数中具有最小值和最大值，在字符串中具有文件名。这些对象存储在一个列表中

List<Entry> minMaxList = new List<Entry>();

我需要找到一个具有最大值和最小值的对象及其文件名。

所以如果我有一个这样的数组

       Entry1                    Entry2                  Entry3
min  max    filename        min  max    filename      min  max    filename
| 2 | 120 |  file1.txt |  | 2 | 150 |  file1.txt |  | 5 | 150 |  file1.txt |

我想得到具有最低值的对象是 Entry1 和 Entry2，而具有最高值的对象是 Entry2 和 Entry3

我试过这个：

var max =  minMaxList.Max(r => r.getMax())

效果很好，但它返回一个值，没有任何其他关于它来自哪里的信息。我需要整个对象，或者至少需要这个值所在的文件名。我想知道它是否可以在一个命令中完成，或者我是否必须再次迭代列表并根据之前选择的最小值和最大值找到所有条目。

4

6 回答 6

3

您始终可以过滤可枚举，而不是只让最大值通过：

var maxvalue = minMaxList.Max(w => w.getMax());
var maxitems = minmaxlist.Where(w => w.getMax() == maxvalue);
于 2015-05-28T13:02:13.377 回答
1

你已经接近了，你只需要添加一个过滤器来找到匹配的项目：

var max =  minMaxList.Max(r => r.getMax())

var itemsWithMax = minMaxList.Where(r => r.getMax() == max);

同样与Min.

我想知道它是否可以在一个命令中完成

可能，使用复杂的分组或连接，但我会先得到一些有用的东西，然后尝试让它变得更好（记住单个查询并不总是比多个查询“更好”）。

于 2015-05-28T13:01:50.837 回答
1

您正在询问解决此问题的最有效方法。

确定最大值/最小值并在之后搜索这些项目需要迭代列表两次。我会在一个循环中手动解决它

List<Entry> ResultList = new List<Entry>();
ResultList.Add(minMaxList[0]);
foreach (Entry item in minMaxList)
{
    if (item.getMax() >= ResultList[0].getMax())
    {
        if (item.getMax() != ResultList[0].getMax())
        {
            ResultList.Clear();
        }
        ResultList.Add(item);
    }
}
于 2015-05-28T13:31:32.710 回答
0

尝试通过以下方式分组：

    var grpWithMaxVaues = minMaxList.GroupBy(c => c.getMax())
                                    .OrderByDescending(c => c.Key)
                                    .FirstOrDefault() 

        var max =   grpWithMaxVaues.FirstOrDefault();

Console.WriteLine(max.FileName);
于 2015-05-28T13:04:41.277 回答
0

我发现这是最短的方法。

var newList = new List<Hero>();
var maxValue = newList.OrderByDescending(x => x.Level).ToList()[0];
于 2020-05-26T18:14:11.357 回答
-1

给你，像这样的东西。

允许您在列表的一个枚举中找到最小值和最大值，这可能比多次枚举列表更快，就像在其他答案中一样。

这是一个工作演示。

我对使用单元素数组来存储值并不完全满意，但它们使种子的值类型属性可变。这避免了不断重新分配聚合的需要。

var minMaxInfo = minMaxList.Skip(1)
    .Aggregate(
        new
        { 
            Max = new int[] { minMaxList[0].Max },
            MaxIndexes = new List<int> { 0 },
            Min = new int[] { minMaxList[0].Min },
            MinIndexes = new List<int> { 0 },
            Index = new int[] { 0 }
        },
        (r, t) =>
        {
            r.Index[0]++;       
            if (t.Min < r.Min[0])
            {
                r.Min[0] = t.Min;
                r.MinIndexes.Clear();
                r.MinIndexes.Add(r.Index[0]);
            } 
            else if (t.Min == r.Min[0])
            {
                r.MinIndexes.Add(r.Index[0]);   
            }

            if (t.Max > r.Max[0])
            {
                r.Max[0] = t.Max;
                r.MaxIndexes.Clear();
                r.MaxIndexes.Add(r.Index[0]);
            }
            else if (t.Max == r.Max[0])
            {
               r.MaxIndexes.Add(r.Index[0]);
            }

            return r;
        });

允许，

Console.WriteLine("MaxValue: {0}", minMaxInfo.Max[0]);
Console.WriteLine(
    "MaxFiles: {0}",
    string.Join(
        ", ",
        minMaxInfo.MaxIndexes.Select(i => minMaxList[i].FileName)));
Console.WriteLine("MinValue: {0}", minMaxInfo.Min[0]);
Console.WriteLine(
    "MinFiles: {0}",
    string.Join(
        ", ",
        minMaxInfo.MinIndexes.Select(i => minMaxList[i].FileName)));
于 2015-05-28T13:20:34.523 回答