### Abstract

It is well known that n integers in the range [1, n
^{c}] can be sorted in O(n) time in the RAM model using radix sorting. More generally, integers in any range [1, U] can be sorted in O(n√log log n) time [5]. However, these algorithms use O(n) words of extra memory. Is this necessary? We present a simple, stable, integer sorting algorithm for words of size O(log n), which works in O(n) time and uses only O(1) words of extra memory on a RAM model. This is the integer sorting case most useful in practice. We extend this result with same bounds to the case when the keys are read-only, which is of theoretical interest. Another interesting question is the case of arbitrary c. Here we present a black-box transformation from any RAM sorting algorithm to a sorting algorithm which uses only O(1) extra space and has the same running time. This settles the complexity of in-place sorting in terms of the complexity of sorting.

Original language | English (US) |
---|---|

Title of host publication | Algorithms - ESA 2007 - 15th Annual European Symposium, Proceedings |

Pages | 194-205 |

Number of pages | 12 |

State | Published - Dec 1 2007 |

Event | 15th Annual European Symposium on Algorithms, ESA 2007 - Eilat, Israel Duration: Oct 8 2007 → Oct 10 2007 |

### Publication series

Name | Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) |
---|---|

Volume | 4698 LNCS |

ISSN (Print) | 0302-9743 |

ISSN (Electronic) | 1611-3349 |

### Conference

Conference | 15th Annual European Symposium on Algorithms, ESA 2007 |
---|---|

Country | Israel |

City | Eilat |

Period | 10/8/07 → 10/10/07 |

### Fingerprint

### ASJC Scopus subject areas

- Computer Science(all)
- Biochemistry, Genetics and Molecular Biology(all)
- Theoretical Computer Science

### Cite this

*Algorithms - ESA 2007 - 15th Annual European Symposium, Proceedings*(pp. 194-205). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 4698 LNCS).

**Radix sorting with no extra space.** / Franceschini, Gianni; Muthukrishnan, Shanmugavelayutham; Pǎtraşcu, Mihai.

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

*Algorithms - ESA 2007 - 15th Annual European Symposium, Proceedings.*Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 4698 LNCS, pp. 194-205, 15th Annual European Symposium on Algorithms, ESA 2007, Eilat, Israel, 10/8/07.

}

TY - GEN

T1 - Radix sorting with no extra space

AU - Franceschini, Gianni

AU - Muthukrishnan, Shanmugavelayutham

AU - Pǎtraşcu, Mihai

PY - 2007/12/1

Y1 - 2007/12/1

N2 - It is well known that n integers in the range [1, n c] can be sorted in O(n) time in the RAM model using radix sorting. More generally, integers in any range [1, U] can be sorted in O(n√log log n) time [5]. However, these algorithms use O(n) words of extra memory. Is this necessary? We present a simple, stable, integer sorting algorithm for words of size O(log n), which works in O(n) time and uses only O(1) words of extra memory on a RAM model. This is the integer sorting case most useful in practice. We extend this result with same bounds to the case when the keys are read-only, which is of theoretical interest. Another interesting question is the case of arbitrary c. Here we present a black-box transformation from any RAM sorting algorithm to a sorting algorithm which uses only O(1) extra space and has the same running time. This settles the complexity of in-place sorting in terms of the complexity of sorting.

AB - It is well known that n integers in the range [1, n c] can be sorted in O(n) time in the RAM model using radix sorting. More generally, integers in any range [1, U] can be sorted in O(n√log log n) time [5]. However, these algorithms use O(n) words of extra memory. Is this necessary? We present a simple, stable, integer sorting algorithm for words of size O(log n), which works in O(n) time and uses only O(1) words of extra memory on a RAM model. This is the integer sorting case most useful in practice. We extend this result with same bounds to the case when the keys are read-only, which is of theoretical interest. Another interesting question is the case of arbitrary c. Here we present a black-box transformation from any RAM sorting algorithm to a sorting algorithm which uses only O(1) extra space and has the same running time. This settles the complexity of in-place sorting in terms of the complexity of sorting.

UR - http://www.scopus.com/inward/record.url?scp=38049066452&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=38049066452&partnerID=8YFLogxK

M3 - Conference contribution

SN - 9783540755197

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 194

EP - 205

BT - Algorithms - ESA 2007 - 15th Annual European Symposium, Proceedings

ER -