3 guides and tools
Complexity fundamentals
Learn the growth curves behind common algorithms and use Big-O as a practical code review language.
Learning path
Algorithms and complexity for backend developers
A curated route through Big-O, array patterns, monotonic stacks, intervals, graph traversal, heaps, probabilistic structures, Java collection complexity, and practical backend performance thinking.
6 guides and tools
Array and subarray patterns
Study windows, pointers, prefix sums, monotonic stacks, and interval frontiers for array and range problems.
3 guides and tools
Search and sorted data
Understand binary search, sorted input requirements, logarithmic growth, and lookup tradeoffs.
4 guides and tools
Heaps and top K
Use heap-backed priority queues for ranking, scheduling, streaming medians, k-way merge, and top K.
3 guides and tools
Graph traversal
Choose BFS or DFS for reachability, shortest unweighted paths, components, cycles, and dependency-style traversals.
3 guides and tools
Probabilistic data structures
Use Bloom filters and hashing to avoid expensive negative lookups while keeping correctness in an exact source of truth.
4 guides and tools
Java collection choices
Connect algorithm complexity to everyday backend collection choices, maps, lists, queues, and sets.
Start here
Pillar guides
These articles are the strongest entry points into the algorithms and complexity cluster.
Algorithms Feb 4, 2026 4 min read
Big-O Notation Explained for Backend Developers
Learn Big-O notation with practical backend examples, including arrays, hash maps, sorting, nested loops, and database-like thinking.
Algorithms Jul 1, 2026 5 min read
Sliding Window Algorithm Explained
Learn the sliding window algorithm pattern with Java examples, fixed windows, variable windows, two pointers, complexity, and common mistakes.
Algorithms Jul 1, 2026 5 min read
Two Pointers Algorithm Explained
Learn the two pointers algorithm pattern with Java examples for sorted arrays, pairs, partitions, linked lists, complexity, and common mistakes.
Algorithms Jul 1, 2026 4 min read
Prefix Sum Algorithm Explained
Learn prefix sums with Java examples, range-sum queries, subarray patterns, difference arrays, complexity, and when preprocessing is worth it.
Algorithms Jul 25, 2026 7 min read
Monotonic Stack Explained
Learn how monotonic stacks solve next-greater, stock-span, temperature, and histogram problems in linear time with practical Java examples.
Algorithms Jul 25, 2026 6 min read
Merge Intervals Explained
Learn the merge intervals pattern, endpoint semantics, sorting invariants, Java implementation, complexity, edge cases, and scheduling variants.
Algorithms Jul 25, 2026 7 min read
Graph Traversal: BFS vs DFS
Compare breadth-first and depth-first graph traversal, choose the right strategy, and implement safe iterative Java versions with complexity and tests.
Algorithms Jul 25, 2026 7 min read
Heap Patterns Explained
Recognize heap patterns for top K, kth elements, streaming medians, k-way merge, and scheduling with safe Java PriorityQueue examples.
Algorithms Jul 25, 2026 8 min read
Bloom Filter Explained
Learn how Bloom filters trade small false-positive risk for compact membership checks, including sizing math, Java BitSet code, and backend use cases.
Java May 10, 2026 6 min read
Time Complexity of Java Collections
A practical reference for Java collection time complexity, including ArrayList, LinkedList, HashMap, TreeMap, HashSet, and PriorityQueue.
Algorithms Jun 28, 2026 4 min read
Binary Search Explained
Learn how binary search works, when it applies, common off-by-one mistakes, and how to implement iterative binary search in Java.
Algorithms Jun 28, 2026 4 min read
Top K Elements Explained
Learn common ways to solve top K elements problems with sorting, heaps, and Java PriorityQueue, including complexity tradeoffs.
Java Jan 14, 2026 4 min read
Java PriorityQueue Explained with Practical Examples
Learn how Java PriorityQueue works, when to use it, how ordering is defined, and common pitfalls around iteration and custom comparators.
Related tools
Local tools for algorithm study and code review
Use these browser-based tools while comparing complexity, documenting examples, or reviewing snippets.
Available tool
Big-O Cheat Sheet
Look up common Big-O complexities for Java collections, algorithms, and backend patterns with a fast browser-based reference table.
Open toolAvailable tool
JSON Formatter
Format, validate, minify, and copy JSON locally in your browser without sending input to a server.
Open toolAvailable tool
Text Diff Checker
Compare two text snippets locally in your browser with line-by-line differences for JSON, SQL, config files, logs, and API responses.
Open toolAvailable tool
Markdown Table Generator
Convert CSV, TSV, or pasted rows into Markdown tables locally in your browser for READMEs, API docs, technical notes, and reports.
Open toolHow to study
Connect patterns to pressure.
Algorithms are easier to retain when they explain real pressure: repeated scans, expensive sorting, memory overhead, slow pagination, lookup hot paths, ranking, and missing indexes.
Start with Big-O vocabulary, then study one pattern at a time. Use sliding windows for contiguous ranges, two pointers for sorted scans, prefix sums for repeated range queries, and binary search for sorted or monotonic search spaces, heaps for repeated priority access, and Java collection complexity when choosing everyday data structures.
For deeper collection tradeoffs, browse the Java Collections Learning Path.
FAQ
Algorithms and complexity learning questions
What algorithms should backend developers learn first?
Start with Big-O, arrays and lists, hashing, sliding window, two pointers, prefix sums, monotonic stacks, intervals, binary search, graph traversal, and heaps.
Is Big-O only useful for interviews?
No. Big-O helps backend developers spot repeated scans, nested loops, expensive sorting, missing indexes, N+1 query patterns, and collection choices that will not scale.
When should I use a heap or PriorityQueue?
Use a heap-backed priority queue when you repeatedly need the next smallest, largest, earliest, cheapest, or highest-priority item without sorting everything each time.
How should I study algorithm complexity with Java collections?
Compare the full workflow: building the collection, lookup, insertion, removal, iteration, sorting, memory overhead, and whether the data is shared across threads.