algorithms and data structures

This work proposes a general type system and an enhanced type inference algorithm that enable fully automated amortized analysis of purely functional data structures, such as skew heaps and leftist heaps. Departing from hand-crafted potential functions, the approach introduces path-sensitive reasoning, data structure invariants, and configurable piecewise potential templates, thereby supporting modular resource analysis applicable to arbitrary classes of potential functions. Implemented in Haskell, the system successfully reproduces and verifies the classical amortized complexity bounds for skew heaps and leftist heaps under all known potential functions, demonstrating its effectiveness in both precision and completeness. This significantly extends the frontier of automated amortized analysis.

This work addresses the design of priority queues supporting efficient insert, decrease-key, and extract-min operations. It proposes a novel partition-based heap structure composed of $O(\log n)$ doubly linked lists that are internally unordered yet globally sorted. By introducing a new strategy of binary partitioning and merging of these lists—relying solely on elementary operations such as binary search and list concatenation—the paper pioneers the application of partitioning techniques to simple heap design. The resulting data structure achieves $O(\log \log n)$ amortized time for both insert and decrease-key operations, and $O(\log n)$ time for extract-min, thereby outperforming traditional heap structures in theoretical efficiency.

To address data redundancy and redundant computation caused by information propagation in whole-program pointer analysis, this paper proposes LatticeHashForest—a dynamic deduplication data structure integrating lattice theory with a hash forest architecture. Its key contributions are: (1) a multi-level element deduplication mechanism; (2) on-the-fly structural reduction for nested aggregate structures; and (3) automatic sharing and dynamic modifiability. Evaluated on million-scale pointer analysis benchmarks, LatticeHashForest reduces memory footprint to near-zero and achieves over 4× end-to-end speedup. The implementation—fully realized in C++—provides a standardized API and comprehensive documentation. By enabling scalable, low-overhead high-dimensional abstract value propagation, it serves as foundational infrastructure for compiler optimization and static analysis.

This paper addresses excessive memory overhead of data structures in Java applications. We propose an automated optimization method that synergistically combines runtime profiling with ahead-of-time (AOT) compilation. By collecting fine-grained, allocation-site-level usage characteristics—such as element count, access patterns, and object lifetime—we construct lightweight behavioral profiles. These profiles drive automatic, end-to-end replacement of standard library data structures with memory-efficient alternatives during GraalVM Native Image AOT compilation—requiring no manual intervention. Our key contribution is the deep integration of dynamic configuration analysis and static compilation, enabling precise, context-aware injection of customized, memory-optimized implementations. Evaluation across multiple benchmarks demonstrates up to 13.85% reduction in memory footprint; average reductions are 1.63% on standard benchmarks and 2.94% on microservice workloads.

Traditional tree indexes (e.g., red-black trees, B+ trees) suffer severe performance degradation in big-data scenarios due to frequent storage accesses. To address this, we propose the Linked Array Tree (LAT), a constant-time index structure based on a sparse, non-migrating hierarchical array layout. LAT eliminates pointer indirections and dynamic rebalancing entirely by employing compact array indexing, level-wise address mapping, and static memory allocation. It is the first index structure to guarantee strict O(1) worst-case time complexity for search, insertion, and deletion. Experimental evaluation demonstrates that LAT consistently outperforms baseline indexes under both dense and sparse data distributions: it reduces memory overhead by 30–60% and improves lookup throughput by over 3.2×.

This work addresses the poor memory locality and limited parallelizability of recursive algebraic data types (ADTs) under the conventional Array-of-Structures (AoS) memory layout, where fields are interleaved. To overcome these limitations, the paper introduces the first extension of the Structure-of-Arrays (SoA) paradigm to recursive ADTs, proposing a multi-buffer factorized layout that separates storage by field to enhance memory access efficiency. The authors design SoCal, a functional programming language, together with its compiler Colobus, which automatically transforms programs to operate on this novel layout. Evaluated on tree-processing benchmarks, the approach achieves a geometric mean speedup of 1.46×, demonstrating significant improvements in both performance and scalability.

Traditional program semantic graphs struggle to uniformly represent the multi-way colocation, routing constraints, and higher-order product structures of geometric algebra inherent in spatial computing, thereby hindering the co-optimization of compiler transformations and physical correctness. This work proposes the Program Hypergraph (PHG), which generalizes binary edges to arbitrary-arity hyperedges and formally introduces hypergraphs into compiler intermediate representations for the first time. PHG naturally encodes mesh topology and Clifford algebra gradings via k-simplices. Integrated with an Abelian group–based dimensional type system (DTS), PHG enables unified reasoning—within a single structure—over geometric correctness, memory layout, precision selection, and hardware partitioning. This framework achieves end-to-end physics-aware compilation with automatic sparsity inference, eliminating the need for manual specialization and significantly enhancing both performance and portability of geometric algebra neural networks.

This work addresses the challenges of high startup latency and low query efficiency in graph analytics under lakehouse architectures. The authors propose a lakehouse-native graph processing engine that maps lakehouse tables to vertex and edge types in a property graph and enables efficient querying through GSQL. Key innovations include loading only graph topology to accelerate system initialization, designing a graph-aware caching mechanism, and developing two lakehouse-optimized parallel primitives for graph computation. Experimental evaluation demonstrates that the proposed system significantly outperforms PuppyGraph—the current state-of-the-art—in both startup time and query latency across a range of workloads.

This work addresses classical parameterized graph problems—including $k$-Path, MaxLeaf SubTree, and Tree Multicut—under memory-constrained settings. Moving beyond conventional vertex/edge deletion paradigms, we introduce a novel graph structural compression scheme coupled with lightweight tree decomposition traversal. Our approach integrates controlled recursion depth with polylogarithmic-space dynamic programming. This yields the first unified framework achieving $f(k) cdot mathrm{poly}(n)$ time and $g(k) cdot mathrm{polylog}(n)$ space complexity for these problems. Crucially, our algorithms avoid $Omega(mathrm{poly}(n))$ memory overhead, enabling scalability from gigabyte- to terabyte-scale graphs. The proposed methods significantly alleviate memory bottlenecks in large-scale graph processing and constitute the first systematic sublinear-space solution for parameterized graph computation in memory-sensitive environments.