George Lagogiannis

Optimal finger search trees in the pointer machine

We develop a new finger search tree with worst-case constant update time in the Pointer Machine (PM) model of computation. This was a major problem in the field of Data Structures and was tantalizingly open for over twenty years while many attempts by researchers were made to solve it. The result comes as a consequence of the innovative mechanism that guides the rebalancing operations combined with incremental multiple splitting and fusion techniques over nodes.

Strict fibonacci heaps

We present the first pointer-based heap implementation with time bounds matching those of Fibonacci heaps in the worst case. We support make-heap, insert, find-min, meld and decrease-key in worst-case O(1) time, and delete and delete-min in worst-case O(lg n) time, where n is the size of the heap. The data structure uses linear space. A previous, very complicated, solution achieving the same time bounds in the RAM model made essential use of arrays and extensive use of redundant counter schemes to maintain balance. Our solution uses neither. Our key simplification is to discard the structure of the smaller heap when doing a meld. We use the pigeonhole principle in place of the redundant counter mechanism.

A time efficient indexing scheme for complex spatiotemporal retrieval

The paper is concerned with the time efficient processing of spatiotemporal predicates, i.e. spatial predicates associated with an exact temporal constraint. A set of such predicates forms a buffer query or a Spatio-temporal Pattern (STP) Query with time. In the more general case of an STP query, the temporal dimension is introduced via the relative order of the spatial predicates (STP queries with order). Therefore, the efficient processing of a spatiotemporal predicate is crucial for the efficient implementation of more complex queries of practical interest. We propose an extension of a known approach, suitable for processing spatial predicates, which has been used for the efficient manipulation of STP queries with order. The extended method is supported by efficient indexing structures. We also provide experimental results that show the efficiency of the technique.

A new algorithm for rectangle enclosure reporting

Abstract We present a new algorithm for reporting all the enclosures in a set of plane rectangles in O (n log n log log n+k log log n) time and O (n) space ( k denotes the output size). The result is already known but the proposed algorithm uses simple data structures.

Partially persistent B-trees with constant worst-case update time

We present two solutions for achieving a partially persistent B-tree with a worst case constant update time, in the case that the position of the update is given. The motivation for this work came from the observation that a known, general approach, which reduces the update cost of partially persistent data structures to a constant, has an inherent weakness concerning partially persistent B-trees, because it creates big nodes that cannot be retrieved from secondary memory in a constant time. Due to this, the I/O complexity of the resulting partially persistent B-tree is affected. Thus, we attack this specific problem, i.e. we do not develop a general approach for all partially persistent data structures. For our objectives, we add partial persistence to an ephemeral B-tree with constant worst case update time, by applying two known general methods, the fat-node and the node-copying method, that transform an ephemeral data structure into a partially persistent. The solution based on node-copying is asymptotically optimal.

Indexing moving objects: A real time approach

Indexing moving objects usually involves a great amount of updates, caused by objects reporting their current position. In order to keep the present and past positions of the objects in secondary memory, each update introduces an I/O and this process is sometimes creating a bottleneck. In this paper we deal with the problem of minimizing the number of I/Os in such a way that queries concerning the present and past positions of the objects can be answered efficiently. In particular we propose a new approach that achieves an asymptotically optimal number of I/Os for performing the necessary updates. The approach is based on the assumption that the primary memory suffices for storing the current positions of the objects.

PARENT QUERIES OVER DYNAMIC BALANCED PARENTHESIS STRINGS

We maintain a balanced parenthesis string under insertions and deletions of parenthesis-pairs in such a way that we can efficiently answer parent queries, i.e., given a parenthesis-pair, we want to find the pair that immediately encloses it. Each parenthesis symbol is attached on a node, and we have n such nodes drawn on a straight line. We achieve O(logn/loglogn) worst-case time per operation on a Pointer Machine, matching the known lower bound on the problem. By transferring our solution to a RAM, we are able to achieve worst case time per update, assuming that we know in advance that the parenthesis-pair to be inserted does not destroy the balance of the parenthesis string.