private void Merge(T[] items, ISortOperator <T> sortOperator, int leftIndex, int leftLength, int rightIndex, int rightLength)
{
T[] array = new T[leftLength + rightLength];
for (int i = 0, iLeft = leftIndex, iRight = rightIndex; i < array.Length; i++)
{
if (iLeft < leftIndex + leftLength)
{
if (iRight < rightIndex + rightLength)
{
array[i] = sortOperator.Compare(items, iLeft, iRight) == -1
? items[iLeft++]
: items[iRight++];
}
else
{
array[i] = items[iLeft++];
}
}
else
{
array[i] = items[iRight++];
}
}
// Can use Buffer.BlockCopy() or MsvcrtCopy for performance
for (var i = 0; i < array.Length; i++)
{
sortOperator.Set(items, array[i], i + leftIndex);
}
}
private void Sort(T[] items, ISortOperator <T> sortOperator, int currentIndex, int maxLength = -1)
{
maxLength = maxLength == -1 ? items.Length : maxLength;
for (int i = currentIndex, maxIndex = i; currentIndex < maxLength; i = maxIndex)
{
var leftIndex = GetLeftIndex(i);
var rightIndex = GetRightIndex(i);
if (leftIndex < maxLength && sortOperator.Compare(items, leftIndex, maxIndex) == 1)
{
maxIndex = leftIndex;
}
if (rightIndex < maxLength && sortOperator.Compare(items, rightIndex, maxIndex) == 1)
{
maxIndex = rightIndex;
}
if (i == maxIndex)
{
return;
}
sortOperator.Swap(items, i, maxIndex);
}
}
private static void AddNode(T[] items, ISortOperator <T> sortOperator, TreeNode <T> node, ref TreeNode <T> root)
{
var currentNode = root;
while (currentNode != null)
{
if (sortOperator.Compare(items, node.Index, currentNode.Index) == -1)
{
if (currentNode.Left != null)
{
currentNode = currentNode.Left;
}
else
{
currentNode.Left = node;
currentNode = null;
}
}
else
{
if (currentNode.Right != null)
{
currentNode = currentNode.Right;
}
else
{
currentNode.Right = node;
currentNode = null;
}
}
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var buckets = new Queue <T> [10];
for (var i = 0; i < buckets.Length; i++)
{
buckets[i] = new Queue <T>();
}
var maxDigits = GetMaxDigitsCount(items);
for (var digit = 0; digit < maxDigits; digit++)
{
foreach (T item in items)
{
buckets[GetDigit(item.GetHashCode(), digit)].Enqueue(item);
}
int i = 0;
foreach (var bucket in buckets)
{
while (bucket.Count > 0)
{
sortOperator.Compare(items, 0, 0); // Just for visual
items[i++] = bucket.Dequeue();
}
}
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
while (!items.IsSorted())
{
for (var i = 0; i < items.Length; i++)
{
sortOperator.Swap(items, 0, Random.Next(0, items.Length));
}
}
}
public Sorter()
{
var sortOperator = new EventsSortOperator <T>();
sortOperator.SetEvent += OnSet;
sortOperator.SwapEvent += OnSwap;
sortOperator.CompareEvent += OnCompare;
_sortOperator = sortOperator;
}
private static void Sort(T[] items, ISortOperator <T> sortOperator, int left, int right)
{
if (left >= right)
{
return;
}
var pivot = Split(items, sortOperator, left, right);
Sort(items, sortOperator, left, pivot - 1);
Sort(items, sortOperator, pivot + 1, right);
}
private static void Add(T[] items, ISortOperator <T> sortOperator, TreeNode <T> node, ref int count, ref TreeNode <T> root)
{
if (root == null)
{
root = node;
count++;
return;
}
AddNode(items, sortOperator, node, ref root);
count++;
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var length = items.Length - 1;
for (var i = 0; i < length; i++)
{
while (i >= 0 && sortOperator.Compare(items, i, i + 1) == 1)
{
sortOperator.Swap(items, i, i + 1);
i--;
}
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var count = 0;
for (var i = items.Length; i >= 0; i--)
{
Sort(items, sortOperator, i);
count++;
}
for (var i = count - 1; i >= 0; i--)
{
sortOperator.Swap(items, 0, i);
Sort(items, sortOperator, 0, i);
}
}
private void Sort(T[] items, ISortOperator <T> sortOperator, int index, int length)
{
if (length == 1)
{
return;
}
var leftLength = length >> 1;
var rightIndex = index + leftLength;
var rightLength = length - leftLength;
Sort(items, sortOperator, index, leftLength);
Sort(items, sortOperator, rightIndex, rightLength);
Merge(items, sortOperator, index, leftLength, index + leftLength, length - leftLength);
}
private static int Split(T[] items, ISortOperator <T> sortOperator, int left, int right)
{
var pointer = left;
for (var i = left; i <= right; i++)
{
if (sortOperator.Compare(items[i], items[right]) == -1)
{
sortOperator.Swap(items, i, pointer++);
}
}
sortOperator.Swap(items, pointer, right);
return(pointer);
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
for (var i = 0; i < items.Length - 1; i++)
{
var minIndex = i;
for (var j = i; j < items.Length; j++)
{
if (sortOperator.Compare(items, j, minIndex) == -1)
{
minIndex = j;
}
}
sortOperator.Swap(items, i, minIndex);
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
for (var i = 1; i < items.Length; i++)
{
for (var j = i; j > 0; j--)
{
if (sortOperator.Compare(items, j, j - 1) == -1)
{
sortOperator.Swap(items, j, j - 1);
}
else
{
break;
}
}
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var count = 0;
TreeNode <T> root = null;
for (var i = 0; i < items.Length; i++)
{
var node = new TreeNode <T>(items[i], i);
Add(items, sortOperator, node, ref count, ref root);
}
T[] ordered = Inorder(ref count, ref root);
for (var i = 0; i < ordered.Length; i++)
{
sortOperator.Set(items, ordered[i], i);
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var isDone = false;
var length = items.Length - 1;
while (!isDone)
{
isDone = true;
for (var i = 0; i < length; i++)
{
if (sortOperator.Compare(items, i, i + 1) == 1)
{
sortOperator.Swap(items, i, i + 1);
isDone = false;
}
}
length--;
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var step = items.Length;
while ((step /= 2) > 0)
{
for (var i = step; i < items.Length; i++)
{
for (var j = i; j >= step; j -= step)
{
if (sortOperator.Compare(items, j, j - step) == -1)
{
sortOperator.Swap(items, j, j - step);
}
else
{
break;
}
}
}
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
var isDone = false;
var left = 0;
var right = items.Length - 1;
while (!isDone)
{
isDone = true;
for (var i = left; i < right; i++)
{
if (sortOperator.Compare(items, i, i + 1) == 1)
{
sortOperator.Swap(items, i, i + 1);
isDone = false;
}
}
if (isDone)
{
return;
}
right--;
for (var i = right; i > left; i--)
{
if (sortOperator.Compare(items, i, i - 1) == -1)
{
sortOperator.Swap(items, i, i - 1);
isDone = false;
}
}
left++;
}
}
public void Sort(T[] items, ISortOperator <T> sortOperator)
{
Sort(items, sortOperator, 0, items.Length);
}
