Skill

data-structure-selection

Choosing optimal data structures based on access patterns and performance requirements.

npx claudepluginhub sethdford/claude-skills --plugin engineer-implementation-patterns

Popularity

Parent stars

Parent forks

Invocation

How this skill is triggered — by the user, by Claude, or both

Slash command

/implementation-patterns:data-structure-selection

User invocable

Model invocable

Inline context

Default effort

Context Preview

The summary Claude sees in its skill listing — used to decide when to auto-load this skill

Matching data structures to your performance requirements.

SKILL.md

43 lines · ~389 tokens

Similar Skills

role-algorithms:data-structures

Implements and selects optimal data structures—hash tables (chaining, Robin Hood), balanced BSTs (AVL, Red-Black), heaps, tries, skip lists, segment/Fenwick trees, Bloom filters, Union-Find—for performance constraints, custom collections, memory optimization.

3 files4 tools

role-algorithms

algorithm-analysis

Big O notation, time/space complexity analysis, and choosing efficient algorithms.

implementation-patterns

storage-selection

Choose the right database technology for specific workloads. Evaluate relational, NoSQL, data warehouses, and search engines. Use when selecting storage systems for new features or optimizing existing ones.

data-architecture

Stats

Parent stars13

Parent forks2

MaintenanceFair

Last CommitMar 11, 2026

Actions

View Source View Plugin View on GitHub View README

Help us improve

Share bugs, ideas, or general feedback.

Stats

Actions

Help us improve

Share bugs, ideas, or general feedback.

Data Structure Selection

Matching data structures to your performance requirements.

Context

You are selecting data structures. Understand tradeoffs: access time, insertion, deletion, memory.

Domain Context

Array: O(1) random access; O(n) insertion

Linked List: O(n) random access; O(1) insertion (if you have pointer)

Hash Table: O(1) average access; O(n) worst case

Tree: O(log n) balanced access; O(n) unbalanced

Heap: O(1) min/max; O(log n) insertion

Instructions

Analyze Access Patterns: Read-heavy? Write-heavy? Random access? Ordered?

Identify Bottleneck: Insertion? Lookup? Iteration?

Compare Options: List pros/cons of 2-3 structures

Benchmark: If unclear, measure with realistic data

Choose: Select structure with best worst-case for bottleneck

Monitor: Track performance; be ready to change if patterns shift

Anti-Patterns

Choosing structure based on familiarity not performance

Not considering space overhead; 10x lookup speedup doesn't matter if memory explodes

Using unbalanced trees; always use balanced (AVL, Red-Black, B-Tree)

Ignoring cache locality; array beats linked list even with worse complexity

Micro-optimizing data structures while algorithmic cost dominates