Add array-based intersection tree implementation for improved memory efficiency

[Copilot]

This PR adds an alternative array-based implementation of the intersection tree data structure that prioritizes memory efficiency over raw execution speed.

Problem

The original intersection tree implementation uses a traditional node-based approach where each tree node is a separate object with references to its children. While this provides good performance, it can be memory-intensive for large datasets due to object overhead and pointer storage.

Solution

The new ArrayTree class implements the same intersection tree functionality using five parallel arrays:

• start[], end[], max_end[]: Store interval data
• left[], right[]: Store child node indices (-1 for None)

Nodes are represented as indices into these arrays rather than separate objects, providing better memory density and cache locality.

Key Features

• 70% Memory Reduction: Significantly lower memory usage compared to the original implementation
• Identical API: Drop-in replacement with the same interface as the original
• 100% Correctness: Produces identical results to the original implementation
• Dynamic Resizing: Arrays grow automatically as needed

Performance Analysis

# Memory comparison for 20,000 intervals
Original: 2.52 MB
Array:    0.76 MB  (69.7% savings)

# Execution time comparison
Original: ~20% faster execution
Array:    Better memory efficiency, slight performance overhead

Files Added

• array_intersection_tree.py: Complete array-based implementation
• test_comparison.py: Comprehensive correctness and performance tests
• performance_analysis.py: Detailed benchmarking tools
• demo.py: Interactive demonstration of both implementations
• ARRAY_IMPLEMENTATION_SUMMARY.md: Complete analysis and recommendations

Usage

import array_intersection_tree as ait

# Same API as original implementation
db = ait.create_db(size=10000)
queries = ait.create_queries(size=100)
results = ait.execute_queries(queries, db)

# Direct tree usage
tree = ait.ArrayTree()
tree.insert((10, 20))
tree.insert((15, 25))
intersections = []
tree.search((12, 18), intersections)

When to Use

Choose Array-Based Implementation:

• Memory usage is critical
• Working with very large datasets
• Memory-constrained environments

Choose Original Implementation:

• Raw execution speed is priority
• Working with moderate dataset sizes
• Prefer object-oriented design

This implementation demonstrates the classic trade-off between memory efficiency and execution performance, giving users flexibility to choose based on their specific requirements.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.