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); }