Huskysort

TL;DR

Huskysort is an improved sorting algorithm that reduces the number of expensive comparisons during the linearithmic phase by combining dual-pivot quicksort and Timsort, leading to faster performance for costly-to-compare objects.

Contribution

The paper introduces Huskysort, a novel sorting approach that optimizes array accesses by combining existing algorithms to improve efficiency for complex object comparisons.

Findings

Huskysort outperforms individual dual-pivot quicksort and Timsort in speed.

The algorithm reduces total array accesses, especially for expensive-to-compare objects.

Significant performance gains are demonstrated in Java implementations.

Abstract

Much of the copious literature on the subject of sorting has concentrated on minimizing the number of comparisons and/or exchanges/copies. However, a more appropriate yardstick for the performance of sorting algorithms is based on the total number of array accesses that are required (the "work"). For a sort that is based on divide-and-conquer (including iterative variations on that theme), we can divide the work into linear, i.e. $\textbf{O}(N)$, work and linearithmic, i.e. $\textbf{O}(N log N)$, work. An algorithm that moves work from the linearithmic phase to the linear phase may be able to reduce the total number of array accesses and, indirectly, processing time. This paper describes an approach to sorting which reduces the number of expensive comparisons in the linearithmic phase as much as possible by substituting inexpensive comparisons. In Java, the two system sorts are dual-pivot quicksort (for primitives) and Timsort for objects. We demonstrate that a combination of these two algorithms can run significantly faster than either algorithm alone for the types of objects which are expensive to compare. We call this improved sorting algorithm Huskysort.