Computer Science Fundamentals
Data structures, algorithms and complexity theory — the foundation of every great engineer.
Data Structures Every Backend Engineer Should Know
A practical tour of the data structures backend engineers actually use day to day — and how to pick the right one.
Arrays vs Linked Lists
When to choose an array (or ArrayList) over a LinkedList in Java — with benchmarks, big-O analysis, and cache-friendliness explained.
Stacks and Queues Explained
Stacks vs queues vs deques in Java — when to use each, big-O behavior, and real backend examples like task queues and expression parsing.
HashMaps and Hash Tables Deep Dive
How HashMap works internally in Java — hashing, buckets, collisions, treeified bins, and the performance pitfalls to avoid.
Trees and Binary Search Trees
Trees, binary trees and binary search trees explained — properties, traversals (in-order, pre-order, post-order), and Java implementation.
Heaps and Priority Queues
How a binary heap works, why it powers PriorityQueue in Java, and where you'll use it — schedulers, top-k problems, Dijkstra.
Graphs Explained for Developers
Graph data structures for developers — adjacency list vs matrix, directed vs undirected, weighted vs unweighted, and the algorithms you'll actually use.
Tries and Prefix Trees
How a Trie works, when to use one, and a Java implementation — the data structure behind autocomplete, spell-check and IP routing.
Choosing the Right Data Structure
A decision framework for picking the right data structure — based on operations, size, ordering and concurrency requirements.
Big O Notation Explained for Developers
Big O notation in plain English — what O(n), O(log n) and O(n²) really mean, with examples and an intuitive ranking of complexities.
Sorting Algorithms Explained (Bubble, Merge, Quick Sort)
The sorting algorithms every developer should understand — Bubble, Merge and Quick Sort — with Java implementations and complexity analysis.
Searching Algorithms (Linear Search vs Binary Search)
Linear search vs binary search — when each applies, Java implementations, off-by-one pitfalls and how to verify correctness.
Recursion Explained with Java Examples
Recursion in Java made simple — base case, recursive case, the call stack, and how to convert recursive solutions to iterative ones.
Dynamic Programming for Beginners
Dynamic programming explained from scratch — memoization vs tabulation, the Fibonacci and Coin Change problems, and when DP is the right tool.
Greedy Algorithms Explained
Greedy algorithms with Java examples — when local choices yield the global optimum, classic problems, and when greedy fails.
Breadth-First Search (BFS) and Depth-First Search (DFS)
BFS and DFS in Java — when to use each, iterative and recursive implementations, and the problems they solve in real backends.
Sliding Window Technique
Master the sliding window technique — fixed and variable windows, with Java examples for substring, subarray and stream problems.
Two Pointer Technique
The two-pointer pattern in Java — opposite ends, fast/slow pointers, and how to turn O(n²) brute force into O(n) elegance.
Common Backend Engineering Algorithm Questions
The algorithm questions that show up most often in backend engineering interviews — with Java patterns and what interviewers actually look for.