Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

Southwest Tree: A Low-Memory Data Structure for Partial Accumulations by Non-Commutative Invertible Operations

Nicholas J. C. Papadopoulos

TL;DR

The paper addresses partial accumulation with updates under non-commutative invertible operations and introduces the Southwest Tree, an in-place data structure that uses phantom nodes to enable traversal without extra memory. It defines node values by $A[i] = A[i - 2^{h_i - 1}] + A[i - 1] + I[i]$ and supports $O(\log_2 N)$ time for both update and accumulate, while storing $N$ elements and modifying the input array in place. The key contributions are a complete in-place structure with phantom nodes, a bottom-up building process, and detailed algorithms for $\text{accumulate}$ and $\text{update}$ that preserve operand order for non-commutative operations, plus a complexity comparison showing memory advantages over the Segment Tree. The work has practical impact for memory-constrained applications requiring fast partial sums with non-commutative composition, broadening the toolkit beyond Fenwick Trees and Segment Trees. $O(\log_2 N)$ time, $O(N)$ space, in-place updates, and support for non-commutative invertible operations collectively position the Southwest Tree as a memory-efficient alternative to traditional structures in relevant workflows.

Abstract

The task of accumulating a portion of a list of values, whose values may be updated at any time, is widely used throughout various applications in computer science. While it is trivial to accomplish this task without any constraints, trivial solutions often sacrifice time complexity in either accumulating or updating the values, one being constant time and the other being linear. To even out the complexity, two well-known data structures have been used to accomplish this task, namely the Segment Tree and the Binary Indexed Tree, which are able to carry out both tasks in O(log_2 N) time for a list of N elements. However, the Segment Tree suffers from requiring auxiliary memory to contain additional values, while the Binary Indexed Tree is unable to handle non-commutative accumulation operations. Here, we present a data structure, called the Southwest Tree, that accomplishes these tasks for non-commutative, invertible accumulation operations in O(log_2 N) time and uses no additional memory to store the structure apart from the initial input array.

Southwest Tree: A Low-Memory Data Structure for Partial Accumulations by Non-Commutative Invertible Operations

TL;DR

The paper addresses partial accumulation with updates under non-commutative invertible operations and introduces the Southwest Tree, an in-place data structure that uses phantom nodes to enable traversal without extra memory. It defines node values by and supports time for both update and accumulate, while storing elements and modifying the input array in place. The key contributions are a complete in-place structure with phantom nodes, a bottom-up building process, and detailed algorithms for and that preserve operand order for non-commutative operations, plus a complexity comparison showing memory advantages over the Segment Tree. The work has practical impact for memory-constrained applications requiring fast partial sums with non-commutative composition, broadening the toolkit beyond Fenwick Trees and Segment Trees. time, space, in-place updates, and support for non-commutative invertible operations collectively position the Southwest Tree as a memory-efficient alternative to traditional structures in relevant workflows.

Abstract

The task of accumulating a portion of a list of values, whose values may be updated at any time, is widely used throughout various applications in computer science. While it is trivial to accomplish this task without any constraints, trivial solutions often sacrifice time complexity in either accumulating or updating the values, one being constant time and the other being linear. To even out the complexity, two well-known data structures have been used to accomplish this task, namely the Segment Tree and the Binary Indexed Tree, which are able to carry out both tasks in O(log_2 N) time for a list of N elements. However, the Segment Tree suffers from requiring auxiliary memory to contain additional values, while the Binary Indexed Tree is unable to handle non-commutative accumulation operations. Here, we present a data structure, called the Southwest Tree, that accomplishes these tasks for non-commutative, invertible accumulation operations in O(log_2 N) time and uses no additional memory to store the structure apart from the initial input array.

Paper Structure

This paper contains 18 sections, 3 theorems, 13 equations, 2 figures.

Table of Contents

  1. Introduction
  2. Related Work
  3. Structure and Layout
  4. Node Children
  5. Node Values
  6. Building the Tree
  7. Operations
  8. Accumulate
  9. Update
  10. Complexity Comparison
  11. Time
  12. Update and Accumulate
  13. Build
  14. Space
  15. Conclusion
  16. ...and 3 more sections

Key Result

Lemma 2

Given an initial array of values, $I$, modified to an array $A$ according to Sec. subsec:building, the value at index $i$ will be $A[i] = \sum_{j = i - 2^{h_i} + 2}^{i} I[j]$ while maintaining the order of operands, where $h_i$ is the height of the node at index $i$.

Figures (2)

  • Figure 1: The array of initial elements. Element values are in black and element indices are in blue.
  • Figure 2: The Southwest Tree tracking initial elements $[1, 3, 5, 7 ,9, 11, 13, 15, 17]$ in the form of (a) a tree and (b) an array. Element values are in black and element indices are in blue. Dashed borders indicate phantom elements, which do not exist in memory.

Theorems & Definitions (4)

  • Definition 1: Partial Sums
  • Lemma 2: Values of the array
  • Theorem 3: Accumulation
  • Theorem 4: Update