Efficient Self-Adjusting Search Trees via Lazy Updates

TL;DR

This paper introduces a new approach to self-adjusting search trees that improves efficiency, simplicity, and cache performance by leveraging lazy updates and existing non-adaptive structures.

Contribution

It presents a novel method for constructing efficient self-adjusting search trees, including a new self-adjusting IST, B-Tree, and Log Tree, with improved complexity and practical implementation benefits.

Findings

Self-adjusting IST has expected complexity O(log(log m)/log ac(x)).

The new constructions are simpler with fewer pointer manipulations.

Enhanced cache efficiency and concurrency support.

Abstract

Self-adjusting data structures are a classic approach to adapting the complexity of operations to the data access distribution. While several self-adjusting variants are known for both binary search trees and B-Trees, existing constructions come with limitations. For instance, existing works on self-adjusting B-Trees do not provide static-optimality and tend to be complex and inefficient to implement in practice. In this paper, we provide a new approach to build efficient self-adjusting search trees based on state-of-the-art non-adaptive structures. We illustrate our approach to obtain a new efficient self-adjusting Interpolation Search Tree (IST) and B-Tree, as well as a new self-adjusting tree called the Log Tree. Of note, our self-adjusting IST has expected complexity in $O(\log \frac{\log m}{\log ac(x)})$, where $m$ is the total number of requests and $ac(x)$ is the number of requests to key $x$. Our technique leads to simple constructions with a reduced number of pointer manipulations: this improves cache efficiency and even allows an efficient concurrent implementation.