How to Sort in a Refrigerator: Simple Entropy-Sensitive Strictly In-Place Sorting Algorithms

2026-03-05

AI Summary

This work addresses the need for strictly in-place sorting in memory-constrained embedded systems, such as refrigerator controllers, by proposing two stack-based natural merge sort algorithms. Leveraging run identification and in-place merging techniques, the algorithms operate with only O(1) extra space and achieve, for the first time, a comparison-based, strictly in-place sorting method whose time complexity adapts to the input entropy H(A), attaining the theoretically optimal bound of O(n(1 + H(A))). The approach balances theoretical optimality with practical deployment efficiency while maintaining code simplicity, offering an effective and practical sorting solution for resource-limited environments.

Technology Category

• Planning, Routing, and Scheduling: Optimization of Spatio-temporal Systems
• Search and Optimization: Mixed Discrete/Continuous Search
• Machine Learning: Learning Preferences or Rankings

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Systems and Infrastructure for Web, Mobile and WoT: Experiences and lessons learnt from Web-based algorithms and system deployments
• Search and Retrieval-Augmented AI: Web learning to rank, online learning, and counterfactual learning for ranking

Abstract

While modern general-purpose computing systems have ample amounts of memory, it is still the case that embedded computer systems, such as in a refrigerator, are memory limited; hence, such embedded systems motivate the need for strictly in-place algorithms, which use only O(1) additional memory besides that used for the input. In this paper, we provide the first comparison-based sorting algorithms that are strictly in-place and have a running time that is optimal in terms of the run-based entropy, H(A), of an input array, A, of size n. In particular, we describe two remarkably simple paradigms for implementing stack-based natural mergesort algorithms to be strictly in-place in O(n(1 + H(A))) time.

Problem

• in-place sorting
• memory-constrained systems
• entropy-sensitive sorting
• embedded systems
• comparison-based sorting

Innovation

• strictly in-place
• entropy-sensitive sorting
• natural mergesort
• run-based entropy
• embedded systems