About clrs-algorithms
clrs-algorithms is a language-agnostic reference skill for data structures and algorithms based on CLRS. It helps developers choose structures, compare complexity, and adapt pseudocode to their programming language.
Key features
- 01Data structure decision guides
- 02Big-O complexity reference
- 03Pseudocode for implementation
- 04Coverage of graph and string algorithms
Use cases
- 01Choosing a structure for a problem
- 02Checking time and space trade-offs
- 03Adapting an algorithm to a language
Install
Copy the command and run it in a terminal.
$
npx skills add https:/After installing, type/clrs-algorithmsin Claude Code to confirm it loaded.
Bundled files
References and scripts installed along with SKILL.md.
complexity-cheat-sheet.mddata-structure-selection.mddata-structures/advanced/binomial-heap.mddisjoint-set.mdfenwick-tree.mdfibonacci-heap.mdsegment-tree.mdskip-list.mdvan-emde-boas-tree.mddata-structures/algorithms/sorting-algorithms.mddata-structures/graphs/adjacency-list.mdadjacency-matrix.mdgraph-algorithms.mdnetwork-flow.mdstrongly-connected-components.mddata-structures/hash-based/bloom-filter.mdhash-set.mdhash-table.mddata-structures/linear/array.mddeque.mddynamic-array.mdlinked-list.mdqueue.mdstack.mddata-structures/strings/string-algorithms.mdsuffix-array.mdsuffix-tree.mddata-structures/trees/avl-tree.mdb-tree.mdbinary-tree.mdDetails
From the project READMECLRS Data Structures & Algorithms Reference
A comprehensive reference for data structures and algorithms based on "Introduction to Algorithms" (CLRS). This skill provides language-agnostic guidance with pseudocode examples that can be translated to any programming language.
When This Skill Activates
This skill automatically activates when you:
- Ask about or need to implement a data structure
- Need to choose between data structures for a problem
- Discuss time/space complexity trade-offs
- Need algorithm implementations (sorting, searching, graph algorithms)
- Mention specific structures: B-tree, heap, hash table, graph, etc.
Quick Data Structure Reference
Linear Structures
| Structure | Access | Search | Insert | Delete | Use When |
|---|---|---|---|---|---|
| Array | O(1) | O(n) | O(n) | O(n) | Known size, index access |
| Dynamic Array | O(1) | O(n) | O(1)* | O(n) | Unknown size, frequent append |
| Linked List | O(n) | O(n) | O(1) | O(1) | Frequent insert/delete |
| Stack | O(1) | O(n) | O(1) | O(1) | LIFO needed |
| Queue | O(1) | O(n) | O(1) | O(1) | FIFO needed |
| Deque | O(1) | O(n) | O(1) | O(1) | Both ends access |
Trees
| Structure | Search | Insert | Delete | Use When |
|---|---|---|---|---|
| Binary Search Tree | O(log n)* | O(log n)* | O(log n)* | Ordered data, frequent search |
| AVL Tree | O(log n) | O(log n) | O(log n) | Guaranteed balance needed |
| Red-Black Tree | O(log n) | O(log n) | O(log n) | Frequent inserts/deletes |
| B-Tree | O(log n) | O(log n) | O(log n) | Disk-based storage |
| Trie | O(m) | O(m) | O(m) | String/prefix operations |
| Heap | O(1)/O(n) | O(log n) | O(log n) | Priority queue needed |
| Splay Tree | O(log n)* | O(log n)* | O(log n)* | Self-adjusting, temporal locality |
| Treap | O(log n)* | O(log n)* | O(log n)* | Randomized balance, split/merge |
| Interval Tree | O(log n) | O(log n) | O(log n) | Interval overlap queries |
| Order-Statistic Tree | O(log n) | O(log n) | O(log n) | Rank/select queries |
| K-D Tree | O(log n)* | O(log n)* | O(log n)* | Multi-dimensional spatial data |
Hash-Based
| Structure | Search | Insert | Delete | Use When |
|---|---|---|---|---|
| Hash Table | O(1)* | O(1)* | O(1)* | Fast key-value lookup |
| Hash Set | O(1)* | O(1)* | O(1)* | Unique membership testing |
| Bloom Filter | O(k) | O(k) | N/A | Probabilistic membership |
Graphs
| Structure | Space | Add Edge | Query Edge | Use When |
|---|---|---|---|---|
| Adjacency List | O(V+E) | O(1) | O(degree) | Sparse graphs |
| Adjacency Matrix | O(V²) | O(1) | O(1) | Dense graphs |
Graph Algorithms
| Algorithm | Time | Use When |
|---|---|---|
| Network Flow | O(VE²) | Max flow, bipartite matching, min cut |
| Strongly Connected Components | O(V+E) | Find SCCs, 2-SAT, dependency analysis |
Strings
| Structure | Build | Search | Use When |
|---|---|---|---|
| Suffix Array | O(n log n) | O(m log n) | Space-efficient string matching |
| Suffix Tree | O(n) | O(m) | Fast pattern matching, LCS |
| String Algorithms | O(m) | O(n) | KMP, Rabin-Karp, Boyer-Moore, Aho-Corasick |
Advanced
| Structure | Use When |
|---|---|
| Skip List | Probabilistic balanced list |
| Disjoint Set | Union-find operations |
| Segment Tree | Range queries with updates |
| Fenwick Tree | Prefix sums with updates |
| Fibonacci Heap | Dijkstra, Prim with O(1) decrease-key |
| Binomial Heap | Mergeable priority queue |
| van Emde Boas Tree | Integer keys with O(log log u) operations |
Algorithms
| Algorithm | Use When |
|---|---|
| Sorting Algorithms | QuickSort, MergeSort, HeapSort, RadixSort, and more |
* = amortized or average case
Decision Guides
- Which Data Structure Should I Use? - Decision guide by use case
- Complexity Cheat Sheet - Quick reference for Big-O
How to Use This Reference
- Choosing a structure: Start with the decision guides
- Learning a structure: Read the full documentation with examples
- Quick reminder: Use the tables above for at-a-glance reference
- Implementation: Follow the pseudocode, adapt to your language
Language Translation Notes
The pseudocode in this reference uses these conventions:
classfor type definitionsfunctionfor methods/functions->for method calls on objects//for comments- Type hints shown as
name: Type
Translate to your language:
- PHP:
class,function,->,//, type hints in docblocks or PHP 8+ - JavaScript/TypeScript:
class,function/arrow,.,//, TS types - Python:
class,def,.,#, type hints - Java/C#: Direct mapping with
new, generics
Based on concepts from "Introduction to Algorithms" by Cormen, Leiserson, Rivest, and Stein (CLRS), MIT Press.
Comments
Markdown supported