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, sliding window, two pointers, prefix sums, binary search, heaps, top K problems, Java collection complexity, and practical backend performance thinking.
4 guides and tools
Array and subarray patterns
Study sliding windows, two pointers, and prefix sums for common array, string, and range-query problems.
3 guides and tools
Search and sorted data
Understand binary search, sorted input requirements, logarithmic growth, and lookup tradeoffs.
3 guides and tools
Heaps and top K
Use heap-backed priority queues when ranking, scheduling, or keeping only the best K items.
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.
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, hash maps and sets, sliding window, two pointers, prefix sums, binary search, sorting, heaps, queues, and the common patterns behind top K and lookup problems.
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.