Return IEnumerable<T> 列表集合中的最高值每一步使用 OrderByDescending

Question

这是我第一次在网站上提问，所以我可能做得不对。我需要在我的 IEnumerable 列表中找到并 return 最高值，但不能显示任何重复项。我也不能使用任何副本或临时集合，或使用不同的。它必须首先通过获取列表并执行 OrderByDescending 来完成。

这是我目前拥有的：

public static IEnumerable<T> PullMax<T> (IEnumerable<T> sourcelist) where T : IComparable
{
    IEnumerable<T> list = sourcelist.OrderByDescending(item => item);

    foreach (T item in list)
    {
        yield return item;
    }
}

这是我从这段代码得到的结果：


foreach (int item in Util.PullMax(Util.GenRange(iMin, iMax).Concat(Util.GenRange(iMin + 5, iMax + 5))))
{
    Console.Write($"\nMaximum Value: {item}");
}

Maximum Value: 15
Maximum Value: 14
Maximum Value: 13
Maximum Value: 12
Maximum Value: 11
Maximum Value: 10
Maximum Value: 10
Maximum Value: 9
Maximum Value: 9
Maximum Value: 8
Maximum Value: 8
Maximum Value: 7
Maximum Value: 6
Maximum Value: 5
Maximum Value: 4
Maximum Value: 3

这应该是预期的结果：

Maximum Value: 15
Maximum Value: 14
Maximum Value: 13
Maximum Value: 12
Maximum Value: 11
Maximum Value: 10
Maximum Value: 9
Maximum Value: 8
Maximum Value: 7
Maximum Value: 6
Maximum Value: 5
Maximum Value: 4
Maximum Value: 3

我被要求显示 Util.GenRange()

public static IEnumerable<int> GenRange(int iMin, int iMax)
        {
            while (true)
            {
                for (int i = iMin; i < iMax; i++)
                {
                    yield return i;
                }
                yield break;
            }
        }

我得到的结果有重复项，但我不能得到它们。我如何在没有任何副本或临时集合甚至不使用 distinct 的情况下摆脱它们？

Answer 1

好吧，完全没有任何临时变量或 distinct 就没有机会了。但是最便宜的解决方法是使用一个临时变量来保存最后返回的值并检查该值是否相同。

也许这个方法应该可以解决问题

 public static IEnumerable<T> PullMax<T>(IEnumerable<T> sourcelist) where T : IComparable
        {
            IEnumerable<T> list = sourcelist.OrderByDescending(item => item);
            if (sourcelist.LongCount() > 0) yield return list.ElementAt(0);
            T tmp = sourcelist.ElementAt(0);
            foreach (T item in list)
            {
                if (item.CompareTo(tmp) < 1) continue;
                tmp = item;
                yield return item;
            }
        }

Answer 2

避免与另一个解决方案的多重枚举问题的方法（即另一个解决方案对可枚举对象进行多次迭代）：

public static IEnumerable<T> PullMax<T> (IEnumerable<T> sourcelist) where T : IComparable
{
    IEnumerable<T> list = sourcelist.OrderByDescending(item => item);
 
    T previousValue = default(T);
    bool firstIteration = true;
 
    foreach (T item in list)
    {
        if (firstIteration)
            firstIteration = false;
        else if (item.CompareTo(previousValue) == 0)
            continue;
        
        previousValue = item;
        yield return item;
    }
}

基本上它总是 returns 第一个元素 - 然后对于第一个元素以外的元素 returns 只有当它们不匹配前一个元素时。对于某些类数据（例如，其中 sourcelist 是 IQueryable），这将显着加快，因为它避免了不必要的计数等

Answer 3

您写道：

I need to find and return the highest values within my IEnumerable list but cannot show any duplicates.

根据您的代码，我了解到您不希望输入序列中的最大值，而是希望这些值按降序排列，没有任何重复项。

为了像 LINQ 一样使用，我将把它创建为扩展方法。如果您不熟悉扩展方法，请阅读 extension methods demystified

扩展方法只是语法糖。它使它查找 reader 就好像您调用的方法是 class.

的方法一样

而不是在静态中调用方法class:

var customers = FetchCustomers();
var maxCustomers = ExtraCustomerFunctions.PullMax(customers);

你可以这样写：

var customers = FetchCustomers();
var maxCustomers = customers.PullMax();

为此，您唯一需要做的就是在静态 class 中创建一个静态方法，并在第一个参数前使用单词 this。

回到你的问题

要求
来自 class T 的对象输入序列，它实现了 IComparable<T>、return 一个序列，其中第一个元素是最大的项目，然后是最大的一个，等等。丢弃重复值。

public class MyExtensionMethods
{
    public static IEnumerable<T> PullMax<T> (this IEnumerable<T> source)
        where T : IComparable<T>
    {
        IEnumerable<T> orderedSource = source.OrderByDescending(item => item);

        using (IEnumerator<T> enumerator = orderedSource.GetEnumerator())
        {
            if (enumerator.MoveNext())
            {
                // The sequence is not empty.
                // return the first item, and remember that you returned this value
                T lastReturnedItem = enumerator.Current;
                yield return lastReturnedItem;

                // enumerate the rest, skip the items with a value that you just returned
                while (enumerator.MoveNext())
                {
                    // Current is either as large as the last returned one, or it is smaller
                    if (enumerator.Curren.Compare(lastReturnedItem) < 0)
                    {
                        // Current is smaller; return it, and remember that you returned it
                        lastReturnedItem = enumerator.Current;
                        yield return lastReturnedItem;
                     }
                }
            }
        }
    }
}

这看起来代码很多，但大部分都是注释。

用法：

int[] numbers = FetchNumbers();
var pulledMaxNumbers = numbers.PullMax();

还有改进的空间！

如果您打算重用此方法，请考虑使其更通用，更像 LINQ。这样对于没有可比性的项目就可以很容易地使用该方法。

客户不具有可比性，但您可以在生日或邮编上进行比较。 PullMax 客户只需稍加改动即可：

// PullMax customers, oldest Customers first:
IEnumerable<Customer> customers = this.FetchCustomers();
var result = customers.PullMax(customer => customer.BirthDay);

为此，创建一个带有属性选择器和通用 IComparer 的方法。像这样：

static IEnumerable<T> PullMax<T>(this IEnumerable<T> source)
{
    return source.PullMax(item => item);
}

static IEnumerable<T> PullMax<T, TKey>(this IEnumerable<T> source,
    Func<T, TKey> propertySelector)
{
    return source.PullMax(propertySelector, null);
}

static IEnumerable<T> PullMax<T, TKey>(this IEnumerable<T> source,
    Func<T, TKey> keySelector,
    IComparer<TKey> comparer)
{
    // TODO: check source and keySelector not null
    if (comparer == null) comparer = Comparer<TKey>.Default;

    // rest of code is similar to code above, difference: check on keySelector
    IEnumerable<T> orderedSource = source.OrderByDescending(keySelector);
    using (IEnumerator<T> enumerator = orderedSource.GetEnumerator())
    {
        if (enumerator.MoveNext())
        {
            T currentValue = enumerator.Current;
            yield return currentValue
            TKey lastKeyValue = keySelector(currentValue);

            while (enumerator.MoveNext())
            {
                currentValue = enumerator.Current;
                TKey keyValue = keySelector(currentValue);
                if (comparer.Compare(keyValue, lastKeyValue) < 0)
                {
                     yield return currentValue;
                     lastKeyValue = keyValue;
                }

等等

您甚至可以将 PullMax 放入 LINQ 串联中：

var result = Customers.Where(customer => customer.City == "New York")
    .PullMax(customer => customer.PostCode)
    .Select(customer => new
    {
        Id = customer.Id,
        Name = customer.Name,
    });

Answer 4

自己编写此算法有很多不同的选择。

然而，在可能的情况下重用代码总是更好，唯一的问题是您还没有找到一种 LINQ 方法，它只通过一次执行不同的排序。

但是有 SortedSet<T>，它基本上是一个排序的 distinct 列表，它声明 O(n log n) 用于插入，并且可以采用 IEnumerable.它不会抛出重复项，只是忽略它们：

static IEnumerable<T> PullMax<T>(this IEnumerable<T> source, IComparer<T> comparer)
{
    return new SortedSet<T>(source, comparer);
}

要使其按降序排列，请使用 -:

翻转 lambda 中的比较结果

list.PullMax((a, b) => -a.CompareTo(b))

Return IEnumerable<T> 列表集合中的最高值每一步使用 OrderByDescending

Return the highest value in the IEnumerable<T> list collection each step using OrderByDescending

c#

linq

ienumerable

还有改进的空间！