blitz-sort

English | 简体中文

Ultra-fast sorting library for JavaScript. Up to 159x faster, averaging 19.9x speedup over V8's native .sort().

Achieves superior performance through type-specific algorithms (radix sort, counting sort, pattern detection, etc.).

Features

• Multi-type support: Uint32, Float64, strings, and objects
• Adaptive algorithms: Automatically selects the best algorithm based on data size and distribution
• Pattern detection: Instant handling of sorted/reversed arrays
• Zero dependencies: Pure JavaScript, no external dependencies
• In-place sorting: Minimal memory overhead

Installation

npm install blitz-sort

Usage

const { ultraSort, sortUint32, sortFloat64, sortStrings, sortObjects } = require('blitz-sort');

// Integer arrays
const integers = new Uint32Array([3, 1, 4, 1, 5, 9, 2, 6]);
ultraSort(integers);
// => Uint32Array [1, 1, 2, 3, 4, 5, 6, 9]

// Float arrays
const floats = new Float64Array([3.14, -2.71, 1.41, -0.5]);
ultraSort(floats);
// => Float64Array [-2.71, -0.5, 1.41, 3.14]

// String arrays
const strings = ['banana', 'apple', 'cherry', 'date'];
ultraSort(strings);
// => ['apple', 'banana', 'cherry', 'date']

// Object arrays with key function
const users = [
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
  { name: 'Charlie', age: 35 }
];
ultraSort(users, { by: u => u.age });
// => [{ name: 'Bob', age: 25 }, { name: 'Alice', age: 30 }, { name: 'Charlie', age: 35 }]

// Descending order
ultraSort(integers, { descending: true });
// => Uint32Array [9, 6, 5, 4, 3, 2, 1, 1]

API

ultraSort(arr, options?)

Main sorting function that auto-detects array type and applies the optimal algorithm.

Parameters:

• arr - Array to sort (mutates in place)
• options.by - Key extraction function for object sorting
• options.descending - Sort in descending order (default: false)

Returns: The sorted array

sortUint32(arr)

Optimized sorting for Uint32Array. Uses:

• Insertion sort for n ≤ 32
• Counting sort for dense integer ranges
• Radix sort for large arrays (n ≥ 5000)

sortFloat64(arr)

Optimized sorting for Float64Array. Includes pattern detection for sorted/reversed arrays.

sortStrings(arr)

Optimized string sorting. Uses:

• Insertion sort for n ≤ 32
• MSD Radix sort for large arrays (n ≥ 1000)

sortObjects(arr, keyFn)

Object sorting using Schwartzian transform for string keys to avoid redundant key computation.

Algorithm Selection

| Data Type | Size | Algorithm | |-----------|------|-----------| | Uint32 | n ≤ 32 | Insertion Sort | | Uint32 | 33-256 | V8 Native | | Uint32 | Dense range | Counting Sort | | Uint32 | n ≥ 5000 | LSD Radix Sort | | Float64 | All | Pattern Detection + V8 Native | | String | n ≤ 32 | Insertion Sort | | String | n ≥ 1000 | MSD Radix Sort | | Object | Numeric key | V8 Native | | Object | String key | Schwartzian Transform |

Performance

Benchmarks comparing blitz-sort vs V8 native .sort():

Integer (Uint32Array)

| Test Case | 10K | 100K | 1M | |-----------|-----|------|-----| | Dense integers | 4.9x | 14.2x | 17.0x | | Sparse integers | 1.8x | 14.7x | 15.7x | | Already sorted | 4.0x | 63.7x | 73.2x | | Reversed | 2.2x | 40.1x | 50.4x | | Many duplicates | 32.3x | 39.8x | 52.3x |

Float (Float64Array)

| Test Case | 10K | 100K | 1M | |-----------|-----|------|-----| | Random floats | 1.0x | 1.0x | 1.0x | | Already sorted | 6.0x | 149.6x | 159.4x | | Mixed pos/neg | 1.0x | 1.0x | 1.0x |

String

| Test Case | 10K | 50K | 100K | |-----------|-----|-----|------| | Random strings | 2.4x | 3.0x | 3.6x | | Already sorted | 0.8x | 2.6x | 2.7x | | Common prefix | 1.1x | 1.2x | 1.4x |

Object

| Test Case | 10K | 50K | 100K | |-----------|-----|-----|------| | By numeric field | 1.1x | 1.1x | 1.2x | | By string field | 1.4x | 1.4x | 2.1x |

Average speedup: 19.9x

Run npm run benchmark to see results on your machine.

How It Works

Pattern Detection

Before sorting, the library samples the first 32 elements to detect:

• Sorted arrays: Return immediately
• Reversed arrays: Simple O(n) reverse operation
• Random arrays: Apply full sorting algorithm

Radix Sort for Integers

For large integer arrays, LSD (Least Significant Digit) radix sort processes numbers byte-by-byte, achieving O(n) time complexity for bounded integers.

MSD Radix Sort for Strings

For large string arrays, MSD (Most Significant Digit) radix sort groups strings by character position, recursively sorting each bucket.

Schwartzian Transform for Objects

When sorting objects by a string key, pre-computes all keys once to avoid redundant keyFn calls during comparisons.

Requirements

• Node.js >= 14.0.0
• Uses BigUint64Array for float-to-int conversion

License

MIT