public static int SortAndCountComparisons( int[] input, PivotStrategy pivotStrategy) { int comparisonsCount = 0; Sort(input, 0, input.Length - 1, pivotStrategy, ref comparisonsCount); return comparisonsCount; }
private void QuickSort(ulong[] array, int start, int end, PivotStrategy strategy, ref int comparsionsCount) { if (start >= end) { return; } var pivotIndex = strategy == PivotStrategy.First ? start : strategy == PivotStrategy.Last ? end : quickSort.CalcMedian(array, start, end); pivotIndex = quickSort.Partition(array, start, end, pivotIndex); comparsionsCount += end - start; QuickSort(array, start, pivotIndex - 1, strategy, ref comparsionsCount); QuickSort(array, pivotIndex + 1, end, strategy, ref comparsionsCount); }
public static int GetPivotIndex(int[] input, int startIndex, int endIndex, PivotStrategy pivotStrategy) { switch (pivotStrategy) { case PivotStrategy.First: return startIndex; case PivotStrategy.Last: return endIndex; case PivotStrategy.MedianOfTrhee: { int arrayLength = endIndex - startIndex + 1; int mediumIndex = arrayLength%2 == 0 ? arrayLength/2 - 1 : arrayLength/2; mediumIndex += startIndex; if (input[startIndex] >= input[mediumIndex]) { if (input[startIndex] <= input[endIndex]) { return startIndex; } if (input[mediumIndex] >= input[endIndex]) { return mediumIndex; } return endIndex; } if (input[startIndex] >= input[endIndex]) { return startIndex; } if (input[mediumIndex] < input[endIndex]) { return mediumIndex; } return endIndex; } default: throw new NotImplementedException(); } }
private static void Partition( int[] input, int startIndex, int endIndex, PivotStrategy pivotStrategy, out int pivotIndex) { pivotIndex = GetPivotIndex(input, startIndex, endIndex, pivotStrategy); Swap(input, startIndex, pivotIndex); pivotIndex = startIndex; int lastLessValueIndex = startIndex + 1; int pivot = input[pivotIndex]; for (int index = startIndex + 1; index <= endIndex; index++) { if (input[index] < pivot) { Swap(input, index, lastLessValueIndex); lastLessValueIndex++; } } Swap(input, pivotIndex, lastLessValueIndex - 1); pivotIndex = lastLessValueIndex - 1; }
/// <summary> /// Initializes a new instance of the <see cref="Solver{T}"/> class. /// </summary> /// <param name="strategy">The pivot strategy that needs to be used.</param> /// <param name="size">The number of equations/variables.</param> protected Solver(PivotStrategy <T> strategy, int size) : base(size) { NeedsReordering = true; Strategy = strategy.ThrowIfNull(nameof(strategy)); }
/// <summary> /// Initializes a new instance of the <see cref="ComplexSolver"/> class. /// </summary> /// <param name="size">The number of equations and variables.</param> /// <param name="strategy">The pivot strategy.</param> public ComplexSolver(int size, PivotStrategy <Complex> strategy) : base(strategy, size) { }
/// <summary> /// Initializes a new instance of the <see cref="Solver{T}"/> class. /// </summary> /// <param name="strategy">The pivot strategy that needs to be used.</param> /// <param name="size">The number of equations/variables.</param> protected Solver(PivotStrategy <T> strategy, int size) : base(size) { NeedsReordering = true; Strategy = strategy; }
/// <summary> /// Initializes a new instance of the <see cref="Solver{T}"/> class. /// </summary> /// <param name="strategy">The pivot strategy that needs to be used.</param> protected Solver(PivotStrategy <T> strategy) { NeedsReordering = true; Strategy = strategy; }
/// <summary> /// Constructor /// </summary> /// <param name="size">Size</param> /// <param name="strategy">Strategy</param> public RealSolver(int size, PivotStrategy <double> strategy) : base(strategy, size) { }
private void QuickSort(ulong[] array, PivotStrategy strategy, ref int comparsionsCount) { var copy = array.ToArray(); QuickSort(copy, 0, copy.Length - 1, strategy, ref comparsionsCount); }
private static void Sort( int[] input, int startIndex, int endIndex, PivotStrategy pivotStrategy, ref int comparisonsCount) { if (endIndex - startIndex <= 0) { return; } comparisonsCount += endIndex - startIndex; int partitionIndex; Partition(input, startIndex, endIndex, pivotStrategy, out partitionIndex); Sort(input, startIndex, partitionIndex - 1, pivotStrategy, ref comparisonsCount); Sort(input, partitionIndex + 1, endIndex, pivotStrategy, ref comparisonsCount); }