static int Partition <TValue>(IList <TValue> values, int lo, int hi, SortOrder sortOrder)
where TValue : IComparable <TValue>
{
int i = lo, j = hi + 1;
while (true)
{
while (SortCommon.ShouldSwap(values, ++i, lo, sortOrder))
{
if (i == hi)
{
break;
}
}
while (SortCommon.ShouldSwap(values, lo, --j, sortOrder))
{
if (j == lo)
{
break;
}
}
if (i >= j)
{
break;
}
SortCommon.Swap(values, i, j);
}
SortCommon.Swap(values, lo, j);
return(j);
}
public static void Sort <TValue>(IList <TValue> values, SortOrder sortOrder = SortOrder.Ascending) where TValue : IComparable <TValue>
{
for (int i = 1; i < values.Count; i++)
{
for (int j = i; j > 0 && SortCommon.ShouldSwap(values, j, j - 1, sortOrder); j--)
{
SortCommon.Swap(values, j, j - 1);
}
}
}
static void Shuffle <TValue>(IList <TValue> values)
{
var rnd = new Random();
for (int i = 0; i < values.Count; i++)
{
var j = rnd.Next(0, values.Count);
SortCommon.Swap(values, i, j);
}
}
static void SortDown <TValue>(IList <TValue> values, SortOrder sortOrder) where TValue : IComparable <TValue>
{
int haltIdx = values.Count - 1;
while (haltIdx > 0)
{
SortCommon.Swap(values, 0, haltIdx--);
Sink(values, 0, haltIdx, sortOrder);
}
}
public static void Sort <TValue>(IList <TValue> values, SortOrder sortOrder = SortOrder.Ascending) where TValue : IComparable <TValue>
{
for (int i = 0; i < values.Count - 1; i++)
{
int toSwap = i;
for (int j = i + 1; j < values.Count; j++)
{
toSwap = ShouldSwap(values, toSwap, j, sortOrder) ? j : toSwap;
}
SortCommon.Swap(values, i, toSwap);
}
}
static void Sink <TValue>(IList <TValue> values, int parentIdx, int haltIdx, SortOrder sortOrder) where TValue : IComparable <TValue>
{
while (2 * parentIdx + 1 <= haltIdx)
{
int childIdx = 2 * parentIdx + 1;
if (childIdx + 1 <= haltIdx && ShouldSwap(values, childIdx, childIdx + 1, sortOrder))
{
childIdx++;
}
if (!ShouldSwap(values, parentIdx, childIdx, sortOrder))
{
break;
}
SortCommon.Swap(values, parentIdx, childIdx);
parentIdx = childIdx;
}
}
public static void Sort <TValue>(IList <TValue> values, SortOrder sortOrder = SortOrder.Ascending) where TValue : IComparable <TValue>
{
int h = 1;
while (h < values.Count)
{
h = 3 * h + 1;
}
while (h >= 1)
{
for (int i = h; i < values.Count; i++)
{
for (int j = i; j >= h && SortCommon.ShouldSwap(values, j, j - h, sortOrder); j -= h)
{
SortCommon.Swap(values, j, j - h);
}
}
h /= 3;
}
}
static bool ShouldSwap <TValue>(IList <TValue> values, int i, int j, SortOrder sortOrder) where TValue : IComparable <TValue>
{
return(sortOrder == SortOrder.Ascending ? SortCommon.Greater(values, i, j) : SortCommon.Lesser(values, i, j));
}
static bool TakeLeft <TValue>(IList <TValue> values, int i, int j, SortOrder sortOrder) where TValue : IComparable <TValue>
{
return(SortCommon.ShouldSwap(values, i, j, sortOrder));
}
