This article includes a list of general references, but it lacks sufficient corresponding inline citations. Please help to improve this article by introducing more precise citations. (July 2017) (Learn how and when to remove this message)

Class | Sorting algorithm |
---|---|

Data structure | Trie |

Worst-case performance | O(wn) |

Worst-case space complexity | O(wn) |

Optimal | ? |

**Burstsort** and its variants are cache-efficient algorithms for sorting strings. They are variants of the traditional radix sort but faster for large data sets of common strings, first published in 2003, with some optimizing versions published in later years.^{[1]}

Burstsort algorithms use a trie to store prefixes of strings, with growable arrays of pointers as end nodes containing sorted, unique, suffixes (referred to as *buckets*). Some variants copy the string tails into the buckets. As the buckets grow beyond a predetermined threshold, the buckets are "burst" into tries, giving the sort its name. A more recent variant uses a bucket index with smaller sub-buckets to reduce memory usage. Most implementations delegate to multikey quicksort, an extension of three-way radix quicksort, to sort the contents of the buckets. By dividing the input into buckets with common prefixes, the sorting can be done in a cache-efficient manner.

Burstsort was introduced as a sort that is similar to MSD radix sort,^{[1]} but is faster due to being aware of caching and related radixes being stored closer to each other due to specifics of trie structure. It exploits specifics of strings that are usually encountered in real world. And although asymptotically it is the same as radix sort, with time complexity of *O*(*wn*) (*w* – word length and *n* – number of strings to be sorted), but due to better memory distribution it tends to be twice as fast on big data sets of strings. It has been billed as the "fastest known algorithm to sort large sets of strings".^{[2]}

- ^
^{a}^{b}Sinha, R.; Zobel, J. (2005). "Cache-conscious sorting of large sets of strings with dynamic tries" (PDF).*Journal of Experimental Algorithmics*.**9**: 1.5. CiteSeerX 10.1.1.599.861. doi:10.1145/1005813.1041517. S2CID 10807318. **^**"Burstsort: Fastest known algorithm to sort large set of strings | Hacker News".

- A burstsort derivative (C-burstsort), faster than burstsort: Sinha, Ranjan; Zobel, Justin; Ring, David (January 2006). "Cache-Efficient String Sorting Using Copying" (PDF).
*Journal of Experimental Algorithmics*.**11**(1.2): 1.2. CiteSeerX 10.1.1.85.3498. doi:10.1145/1187436.1187439. S2CID 3184411. Archived from the original (PDF) on 2007-10-01. Retrieved 2007-05-31. - The data type used in burstsort: Heinz, Steffen; Zobel, Justin; Williams, Hugh E. (April 2002). "Burst Tries: A Fast, Efficient Data Structure for String Keys" (PDF).
*ACM Transactions on Information Systems*.**20**(2): 192–223. CiteSeerX 10.1.1.18.3499. doi:10.1145/506309.506312. S2CID 14122377. Archived from the original (PDF) on 2013-12-05. Retrieved 2007-09-25. - Sinha, Ranjan; Zobel, Justin (2003). "Efficient Trie-Based Sorting of Large Sets of Strings" (PDF).
*Proceedings of the 26th Australasian Computer Science Conference*. Vol. 16. pp. 11–18. CiteSeerX 10.1.1.12.2757. ISBN 978-0-909-92594-9. Archived from the original (PDF) on 2012-02-08. Retrieved 2007-09-25. - Sinha, Ranjan; Wirth, Anthony (March 2010). "Engineering Burstsort: Towards Fast In-Place String Sorting" (PDF).
*ACM Journal of Experimental Algorithmics*.**15**(2.5): 1–24. doi:10.1145/1671970.1671978. S2CID 16410080.

- A burstsort implementation in Java: burstsort4j
- Judy arrays are a type of copy burstsort: C implementation

Theory | |
---|---|

Exchange sorts | |

Selection sorts | |

Insertion sorts | |

Merge sorts | |

Distribution sorts | |

Concurrent sorts | |

Hybrid sorts | |

Other | |

Impractical sorts |