DeepSort 1.1.0

DeepSort

The definitive .NET sorting library — 12 algorithms, adaptive selection, parallel sorting, and full complexity metadata.

DeepSort is the new era of sorting: pick any algorithm by name, let the adaptive engine choose for you, or unleash parallel merge sort for massive datasets. Every algorithm is production-grade, thoroughly tested, and ships with detailed complexity info.

Install

dotnet add package DeepSort

Quick Start

using DeepSort;

int[] numbers = [73, 12, 45, 8, 91, 33, 67, 5, 28];
int[] sorted = DeepSorter.Sort(numbers);

Console.WriteLine(string.Join(", ", sorted));
// 5, 8, 12, 28, 33, 45, 67, 73, 91

Sort returns a new array and leaves the input unchanged.

string[] words = ["banana", "apple", "cherry", "apple"];

DeepSorter.SortInPlace(words);

Console.WriteLine(string.Join(", ", words));
// apple, apple, banana, cherry

Choose Your Algorithm

// Use any of the 12 built-in algorithms
int[] values = [42, 17, 93, 5, 67, 31];

var sorted = DeepSorter.Sort(values, SortAlgorithm.TimSort);
var quick  = DeepSorter.Sort(values, SortAlgorithm.DualPivotQuickSort);
var heap   = DeepSorter.Sort(values, SortAlgorithm.HeapSort);

Let DeepSort Decide

The adaptive engine analyzes your data and picks the best algorithm:

var sorted = DeepSorter.Sort(values, SortAlgorithm.Adaptive);

It considers array size, sortedness ratio, and data type to select the optimal strategy.

Custom Comparers

int[] descending = DeepSorter.Sort(
    values,
    SortAlgorithm.DualPivotQuickSort,
    Comparer<int>.Create((a, b) => b.CompareTo(a)));

Parallel Sorting

For large datasets, parallel merge sort distributes work across all available cores:

var largeArray = Enumerable.Range(0, 1_000_000).Select(_ => Random.Shared.Next()).ToArray();

// Uses all CPU cores for maximum throughput
var sorted = DeepSorter.ParallelSort(largeArray);

// In-place variant
DeepSorter.ParallelSortInPlace(largeArray);

Algorithm Complexity Info

Query complexity metadata at runtime:

var info = DeepSorter.GetComplexity(SortAlgorithm.TimSort);

Console.WriteLine($"Best:    {info.BestTime}");    // O(n)
Console.WriteLine($"Average: {info.AverageTime}");  // O(n log n)
Console.WriteLine($"Worst:   {info.WorstTime}");    // O(n log n)
Console.WriteLine($"Space:   {info.Space}");         // O(n)
Console.WriteLine($"Stable:  {info.IsStable}");      // True

All 12 Algorithms

Full API Reference

Default Sort (Ternary Merge Sort)

• DeepSorter.Sort<T>(IEnumerable<T> values)
• DeepSorter.Sort<T>(IEnumerable<T> values, IComparer<T>? comparer)
• DeepSorter.Sort<T>(ReadOnlySpan<T> values)
• DeepSorter.Sort<T>(ReadOnlySpan<T> values, IComparer<T>? comparer)
• DeepSorter.SortInPlace<T>(T[] values)
• DeepSorter.SortInPlace<T>(T[] values, IComparer<T>? comparer)
• DeepSorter.SortInPlace<T>(Span<T> values)
• DeepSorter.SortInPlace<T>(Span<T> values, IComparer<T>? comparer)

Algorithm Selection

• DeepSorter.Sort<T>(IEnumerable<T> values, SortAlgorithm algorithm)
• DeepSorter.Sort<T>(IEnumerable<T> values, SortAlgorithm algorithm, IComparer<T>? comparer)
• DeepSorter.SortInPlace<T>(T[] values, SortAlgorithm algorithm)
• DeepSorter.SortInPlace<T>(T[] values, SortAlgorithm algorithm, IComparer<T>? comparer)
• DeepSorter.SortInPlace<T>(Span<T> values, SortAlgorithm algorithm)
• DeepSorter.SortInPlace<T>(Span<T> values, SortAlgorithm algorithm, IComparer<T>? comparer)

Parallel Sort

• DeepSorter.ParallelSort<T>(IEnumerable<T> values)
• DeepSorter.ParallelSort<T>(IEnumerable<T> values, IComparer<T>? comparer)
• DeepSorter.ParallelSortInPlace<T>(T[] values)
• DeepSorter.ParallelSortInPlace<T>(T[] values, IComparer<T>? comparer)

Metadata

• DeepSorter.GetComplexity(SortAlgorithm algorithm) → SortComplexity

Memory Behavior

All merge-based algorithms rent buffers from ArrayPool<T> and return them when done — no garbage left behind. In-place algorithms (heap, shell, insertion, bubble, selection, cocktail) use O(1) extra memory.

Build From Source

dotnet restore
dotnet test
dotnet pack src/DeepSort/DeepSort.csproj -c Release

The package file will be created under:

src/DeepSort/bin/Release/DeepSort.1.0.0.nupkg

Publish To NuGet

Create an API key at https://www.nuget.org/account/apikeys, then run:

dotnet nuget push src/DeepSort/bin/Release/DeepSort.1.0.0.nupkg `
  --api-key YOUR_NUGET_API_KEY `
  --source https://api.nuget.org/v3/index.json

If the DeepSort package ID is unavailable, change <PackageId> in src/DeepSort/DeepSort.csproj to a unique name such as Ayush.DeepSort, rebuild, and publish that package instead.

License

MIT