假设我有一些类型的集合,例如
IEnumerable<double> values;
现在我需要从该集合中提取k个最高值,对于某些参数k。这是一种非常简单的方法:
values.OrderByDescending(x => x).Take(k)
但是,这(如果我理解的话)首先对整个列表进行排序,然后选择前k个元素。但是如果列表非常大,并且k相对较小(小于log n),则效率不高 - 列表以O(n * log n)排序,但我想从列表中选择k个最高值应该更像是O(n * k)。
那么,是否有人建议采用更好,更有效的方法来做到这一点?
答案 0 :(得分:6)
这会带来一点性能提升。请注意,它是升序而不是降序,但您应该可以重新调整它(请参阅注释):
static IEnumerable<double> TopNSorted(this IEnumerable<double> source, int n)
{
List<double> top = new List<double>(n + 1);
using (var e = source.GetEnumerator())
{
for (int i = 0; i < n; i++)
{
if (e.MoveNext())
top.Add(e.Current);
else
throw new InvalidOperationException("Not enough elements");
}
top.Sort();
while (e.MoveNext())
{
double c = e.Current;
int index = top.BinarySearch(c);
if (index < 0) index = ~index;
if (index < n) // if (index != 0)
{
top.Insert(index, c);
top.RemoveAt(n); // top.RemoveAt(0)
}
}
}
return top; // return ((IEnumerable<double>)top).Reverse();
}
答案 1 :(得分:1)
考虑以下方法:
static IEnumerable<double> GetTopValues(this IEnumerable<double> values, int count)
{
var maxSet = new List<double>(Enumerable.Repeat(double.MinValue, count));
var currentMin = double.MinValue;
foreach (var t in values)
{
if (t <= currentMin) continue;
maxSet.Remove(currentMin);
maxSet.Add(t);
currentMin = maxSet.Min();
}
return maxSet.OrderByDescending(i => i);
}
测试程序:
static void Main()
{
const int SIZE = 1000000;
const int K = 10;
var random = new Random();
var values = new double[SIZE];
for (var i = 0; i < SIZE; i++)
values[i] = random.NextDouble();
// Test values
values[SIZE/2] = 2.0;
values[SIZE/4] = 3.0;
values[SIZE/8] = 4.0;
IEnumerable<double> result;
var stopwatch = new Stopwatch();
stopwatch.Start();
result = values.OrderByDescending(x => x).Take(K).ToArray();
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
result = values.GetTopValues(K).ToArray();
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);
}
在我的机器上,结果 1002 且 14 。
答案 2 :(得分:0)
这样做的另一种方式(多年来一直没有围绕C#,所以伪代码,对不起)将是:
highestList = []
lowestValueOfHigh = 0
for every item in the list
if(lowestValueOfHigh > item) {
delete highestList[highestList.length - 1] from list
do insert into list with binarysearch
if(highestList[highestList.length - 1] > lowestValueOfHigh)
lowestValueOfHigh = highestList[highestList.length - 1]
}
答案 3 :(得分:0)
如果没有分析,我不会说任何有关性能的内容。在这个答案中,我将尝试实现O(n*k)
take-one-enumeration-for-one-max-value方法。我个人认为订购方法更优越。无论如何:
public static IEnumerable<double> GetMaxElements(this IEnumerable<double> source)
{
var usedIndices = new HashSet<int>();
while (true)
{
var enumerator = source.GetEnumerator();
int index = 0;
int maxIndex = 0;
double? maxValue = null;
while(enumerator.MoveNext())
{
if((!maxValue.HasValue||enumerator.Current>maxValue)&&!usedIndices.Contains(index))
{
maxValue = enumerator.Current;
maxIndex = index;
}
index++;
}
usedIndices.Add(maxIndex);
if (!maxValue.HasValue) break;
yield return maxValue.Value;
}
}
用法:
var biggestElements = values.GetMaxElements().Take(3);
下行:
优势: