/// <summary>
/// 排序去除Top N
/// </summary>
/// <typeparam name="valueType">排序数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="comparer">排序比较器</param>
/// <param name="count">排序数据数量</param>
/// <returns>排序后的数据</returns>
private static valueType[] getRemoveTop <valueType>(valueType[] values, Func <valueType, valueType, int> comparer, int count)
{
valueType[] newValues = new valueType[count];
count = values.Length - count;
uint sqrtMod;
int length = Math.Min(Math.Max(count << 2, count + (int)number.sqrt((uint)values.Length, out sqrtMod)), values.Length);
valueType[] removeValues = new valueType[length];
int readIndex = values.Length - length, copyCount = length - count, removeIndex = copyCount, writeIndex = copyCount;
Array.Copy(values, readIndex, removeValues, 0, length);
rangeSorter <valueType> sort
= new rangeSorter <valueType> {
Array = removeValues, Comparer = comparer, SkipCount = copyCount, GetEndIndex = copyCount
};
sort.Sort(0, --length);
Array.Copy(removeValues, 0, newValues, 0, copyCount);
for (valueType maxValue = removeValues[copyCount]; readIndex != 0;)
{
if (comparer(values[--readIndex], maxValue) <= 0)
{
newValues[writeIndex++] = values[readIndex];
}
else
{
removeValues[--removeIndex] = values[readIndex];
if (removeIndex == 0)
{
sort.Sort(0, length);
removeIndex = copyCount;
maxValue = removeValues[copyCount];
Array.Copy(removeValues, 0, newValues, writeIndex, copyCount);
writeIndex += copyCount;
}
}
}
if (removeIndex != copyCount)
{
sort.Sort(removeIndex, length);
Array.Copy(removeValues, removeIndex, newValues, writeIndex, copyCount - removeIndex);
}
return(newValues);
}
/// <summary>
/// 排序取Top N
/// </summary>
/// <typeparam name="valueType">排序数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="comparer">排序比较器</param>
/// <param name="count">排序数据数量</param>
/// <returns>排序后的数据</returns>
private static list <valueType> getTop <valueType>(valueType[] values, func <valueType, valueType, int> comparer, int count)
{
uint sqrtMod;
int length = Math.Min(Math.Max(count << 2, count + (int)number.sqrt((uint)values.Length, out sqrtMod)), values.Length);
valueType[] newValues = new valueType[length];
int readIndex = values.Length - length, writeIndex = count;
Array.Copy(values, readIndex, newValues, 0, length);
rangeSorter <valueType> sort
= new rangeSorter <valueType> {
Array = newValues, Comparer = comparer, SkipCount = count - 1, GetEndIndex = count - 1
};
sort.Sort(0, --length);
for (valueType maxValue = newValues[sort.GetEndIndex]; readIndex != 0;)
{
if (comparer(values[--readIndex], maxValue) < 0)
{
newValues[writeIndex] = values[readIndex];
if (writeIndex == length)
{
sort.Sort(0, length);
writeIndex = count;
maxValue = newValues[sort.GetEndIndex];
}
else
{
++writeIndex;
}
}
}
if (writeIndex != count)
{
sort.Sort(0, writeIndex - 1);
}
Array.Clear(newValues, count, newValues.Length - count);
return(newValues.left(count));
}
/// <summary>
/// 范围排序
/// </summary>
/// <typeparam name="valueType">排序数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="comparer">排序比较器</param>
/// <param name="skipCount">跳过数据数量</param>
/// <param name="getCount">排序数据数量</param>
/// <returns>排序后的新数据</returns>
public static subArray <valueType> GetRangeSort <valueType>
(valueType[] values, Func <valueType, valueType, int> comparer, int skipCount, int getCount)
{
array.range range = new array.range(values.length(), skipCount, getCount);
if ((getCount = range.GetCount) != 0)
{
if (comparer == null)
{
log.Error.Throw(log.exceptionType.Null);
}
rangeSorter <valueType> sorter = new rangeSorter <valueType>
{
Array = values.copy(),
Comparer = comparer,
SkipCount = range.SkipCount,
GetEndIndex = range.EndIndex - 1
};
sorter.Sort(0, values.Length - 1);
return(subArray <valueType> .Unsafe(sorter.Array, range.SkipCount, getCount));
}
return(default(subArray <valueType>));
}
/// <summary>
/// 范围排序
/// </summary>
/// <typeparam name="valueType">排序数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="comparer">排序比较器</param>
/// <param name="skipCount">跳过数据数量</param>
/// <param name="getCount">排序数据数量</param>
/// <returns>排序后的新数据</returns>
public static collection <valueType> GetRangeSort <valueType>
(valueType[] values, func <valueType, valueType, int> comparer, int skipCount, int getCount)
{
array.range range = new array.range(values.length(), skipCount, getCount);
if ((getCount = range.GetCount) != 0)
{
if (comparer == null)
{
log.Default.Throw(log.exceptionType.Null);
}
rangeSorter <valueType> sorter = new rangeSorter <valueType>
{
Array = values.copy(),
Comparer = comparer,
SkipCount = range.SkipCount,
GetEndIndex = range.EndIndex - 1
};
sorter.Sort(0, values.Length - 1);
return(new collection <valueType>(sorter.Array, range.SkipCount, getCount, true));
}
return(null);
}
