Concurrent Search and Insertion in K-Dimensional Height Balanced Trees

K-Dimensional Height Balanced Trees represent one solution to handle simultaneous tree operations (insertion, search) with multiple value keys in an efficient way. The current paper focuses on discussing some of the intricacies and overhead caused by the concurrency aspects, as well as providing an implementation of the algorithm, together with a discussion regarding its correctness. 1. Context / Related work A fairly common way to organize information is in a hierarchical order. Trees, as a data structure, are a special kind of graph: a connected a-cyclic one. In order to efficiently perform operations on such a data structure (i.e. search, sort, insert, delete), the idea of binary search trees seemed as a valid option. Certain concerns related to the tree operations time complexity pioneered solutions like AVL-Trees, Red-Black Trees (a special type of AVL trees), B-Trees, in the attempt to optimize the time complexity of the tree operations. Multiple dimension height balanced trees are a more generalized type of AVL-tree. In such a data structure, all the basic tree operations (insertions, deletions, searches) can be performed in at most O(log n) time. K-Dimensional Height Balanced Trees take AVL-trees to multiple dimensions. In this case, the data structure is defined such that all the operations are performed in at most O(log n)+k time. After each operation that alters the structure of the data, rebalancing has to be performed, in order to maintain the original height balancing condition. Such a data structure is specially used in dynamic databases, as well as in application that perform information storage and retrieval. 2. Overview of contents In the current paper I will give a brief overview of the originally proposed algorithm [1], discuss about the changes required due to a concurrent approach [2], as well as provide some of the details and design decisions regarding my implementation. I want to mention that, as far as the novelty of this paper goes, the following can be mentioned: the class design and decisions of the java implementation, the attempt to verify the implementation of the algorithm using some existent software tools, as well as extending the object model in order to better support thorough testing. For the ones interested in the mathematical details, I suggest reading the original papers that I base my implementation on.