THE JAVA EDITION

Complete Placement Roadmap 2026

Built for: Absolute beginner, Day 0, targeting product-based / high-package companies,

language locked to Java
Timeline: 6 months (DSA core) + parallel tracks running alongside it

What actually changes when you pick Java: the DSA topics, the order you learn them in, and the 6-month calendar stay
identical — data structures don't care what language you write them in. What genuinely changes is threefold: (1)
several cheat-sheet entries needed rewriting because Java has real behavioral differences from C++ (pass-by-value
semantics, PriorityQueue defaulting to a min-heap, string immutability, the equals()/hashCode() contract), (2) almost
every "best channel" pick has been swapped for a creator who teaches natively in Java instead of narrating in C++, and
(3) the Low-Level Design phase and the resume phase both lean harder into Java now, since OOP and backend work are
Java's home turf.
Quick-Scan Summary — What's Different

Area What changed for the Java track Why it matters

Language recommendation Framed around Java as your committed choice, not You've already decided — this version
(Part 1) "start with C++ instead" stops hedging and commits

Pass-by-value note rewritten (no & reference syntax); C++'s void f(int &x) doesn't exist in
Phase 0 cheat sheet
added primitive vs. wrapper type note Java — trips people up early

String concatenation in a loop is a real

Phase 2 cheat sheet Added a note on String immutability and StringBuilder
O(n²) trap unique to Java

Asked constantly in Java-specific

Phase 4 cheat sheet Added the equals()/hashCode() contract
interviews, no C++/Python equivalent

A very common "which class do I use"

Phase 7 cheat sheet Added: use ArrayDeque, not the legacy Stack class
beginner question in Java

Java hands you a production-grade

Phase 8 cheat sheet Added: TreeMap/TreeSet as a free balanced BST
balanced tree for free

PriorityQueue is a min-heap by default

Phase 9 cheat sheet Added the single most important Java heap gotcha
— opposite of C++'s max-heap default

Every phase's "Best Swapped to Java-native creators wherever a strong one So you're learning DSA in Java, not
channel" exists translating from C++ narration

Java is OOP by construction — you've

Phase 14 (LLD) Reframed as a natural extension, not a new skill
rehearsed LLD habits since Day 0

Java's strongest lane is

Phase 18 (Resume) Added a Java-specific project suggestion backend/enterprise — your portfolio
can reflect that

Part 1 — You've Picked Java: Here's What That Means

Language Strength Weakness Best for

Manual memory concepts,

STL (vector, map, set, priority_queue, stack) maps
pointer syntax — steepest Competitive programming,
C++ closely onto DSA concepts. Fastest raw execution.
climb with no coding performance-critical rounds.
Dominant in competitive programming.
background.

Clean, structured OOP that doubles as

LLD/system-design practice. Collections
More verbose to type
framework covers essentially every data structure Placement-focused prep from
under time pressure; a hair
Java out of the box. No pointer arithmetic — JVM zero; backend/enterprise-
slower than C++ (rarely the
garbage collector handles memory. Equally strong track candidates.
deciding factor).
acceptance across Indian service-based and
product-based companies.

Slower execution (rarely an Beginners optimizing for

Fastest to write. Built-in list, dict, set, heapq,
Python interview issue). No built-in lowest syntax friction;
deque.
balanced BST equivalent. ML/AI/data-track candidates.
 ✎ The one trade-off worth being honest about
• The global competitive-programming world (Codeforces, CodeChef, ICPC) still runs overwhelmingly on C++, so if
serious contest participation becomes a goal later, you'll eventually want conversational fluency in C++ too. That's a
problem for month 8, not month 1 — for placements specifically, Java is a complete, sufficient choice on its own.
• Stay in Java for the full six months. Don't switch mid-prep just because a solution online happens to be in C++ —
translate the logic, not the language.

Part 2 — The Full Concept Ladder

Every phase, rebuilt for Java. How to use each phase: read the checklist (the what), then the cheat sheet (the instant-
recall version you'd want in an interview), then go to the named channel — which teaches the material natively in Java
instead of requiring you to mentally re-type someone else's C++.

Phase 0 — Programming & Math Foundations

☐ Variables, primitive types (int, char, boolean, double...) vs. wrapper classes, casting, autoboxing/unboxing
☐ Conditionals, loops, nested loops
☐ Methods: parameters, return types, and Java's pass-by-value rule (no C++-style & reference parameter)
☐ Arrays basics (1D, 2D) — fixed-size, int[] arr = new int[n];
☐ The Java memory model: stack vs. heap, and why you'll never need to manually free anything
☐ Fast I/O: Scanner (simple, slower) vs. BufferedReader + StringTokenizer (more code, much faster)
☐ Number theory: primes, GCD/LCM, modulo
☐ Bit manipulation basics: AND/OR/XOR/NOT, shifts, checking/setting/clearing a bit

✎ Cheat sheet
• GCD(a,b) = GCD(b, a%b), base case GCD(a,0)=a. LCM(a,b) = (a*b)/GCD(a,b).
• Check bit i: (n >> i) & 1. Set bit i: n | (1 << i). Clear bit i: n & ~(1 << i). Toggle: n ^ (1 << i) — identical syntax in Java.
• Java has no reference parameters. Everything is passed by value: for a primitive, the method gets a copy. For an
object/array parameter, the method gets a copy of the reference — so arr[0]=5 inside the method changes the caller's
array, but arr = new int[10] does NOT change what the caller's variable points to.
• Mod arithmetic: (a + b) % m and (a * b) % m are safe directly; (a - b + m) % m avoids a negative result.
• Scanner is fine for interview-style problems; switch to BufferedReader/StringTokenizer only for competitive
programming with heavy input.

▶JavaBest channel: Kunal Kushwaha's "Java + DSA + Interview Preparation Course" starts at true zero and stays in
for the entire journey. Prefer Hindi+English style instead? Apna College's "Java & DSA" placement course
covers the same ground and is one of the most-followed Java-specific tracks in India.

Phase 1 — Complexity Analysis (do this before Phase 2)

☐ Big-O, Big-Ω, Big-Θ
 ☐ Space complexity
☐ Analyzing loops, nested loops, recursion complexity
☐ Best/average/worst case
☐ Amortized complexity (conceptual)

Cheat sheet — complexity by pattern

Pattern Typical complexity

Single loop over n O(n)

Nested loop (n×n) O(n²)

Loop that halves each time O(log n)

Recursion branching into 2, depth n O(2ⁿ)

Recursion with memoized n states O(n) or O(n·m)

Sorting (comparison-based) O(n log n)

Hash map insert/lookup O(1) average

▶withBest channel: Abdul Bari — this phase is pure mathematical reasoning about growth rates and doesn't change
language. His Big-O playlist explains why these complexities hold, not just a table to memorize.

Phase 2 — Arrays & Strings

☐ Traversal, insertion, deletion, rotation
☐ Prefix sum / suffix sum
☐ Two-pointer technique
☐ Sliding window (fixed and variable size)
☐ Kadane's algorithm
☐ Dutch national flag
☐ String basics, manipulation, palindrome/anagram checks
☐ Naive pattern matching

✎ Cheat sheet
• Two-pointer: use when the array is sorted or you're comparing from both ends (pair sum, reverse, container-with-
most-water).
• Sliding window: triggered by "subarray/substring" + a condition. Fixed size → move both pointers together; variable
size → expand right, shrink left when the condition breaks.
• Kadane's: curr_max = [Link](arr[i], curr_max + arr[i]), track global_max.
• Prefix sum: prefix[i] = prefix[i-1] + arr[i]; range sum [l,r] = prefix[r] - prefix[l-1].
• Dutch flag (3-way partition): three pointers low, mid, high — the standard one-pass approach for sorting 0s/1s/2s.
• Java-specific trap: String objects are immutable. Building a string with result = result + ch inside a loop silently costs
 O(n²) time. Use StringBuilder and .append(), then .toString() once at the end.

▶(takeUforward)
Best channel: Kunal Kushwaha or Pepcoding (Sumit Malik) for native-Java walkthroughs. Keep Striver's
A2Z sheet open too — the sequencing of problems is still the most complete free path, and the
sheet provides Java solutions alongside the C++ ones.

Phase 3 — Searching & Sorting

☐ Linear, binary search (iterative + recursive)
☐ Binary search variants: first/last occurrence, rotated array, 2D matrix, lower/upper bound
☐ Bubble, selection, insertion sort
☐ Merge sort, quick sort
☐ Counting/radix/bucket sort
☐ Stability of sorts

✎ Cheat sheet
• Binary search template: while(lo<=hi){ mid = lo + (hi-lo)/2; if(cond) lo = mid+1; else hi = mid-1; } — plain C-style syntax,
works exactly the same in Java.
• Rotated sorted array: at each step, one half is always properly sorted — figure out which half, then decide which side
to discard.
• Stable sorts: insertion, merge, bubble, counting. Not stable: quick sort, selection sort, heap sort.
• Merge sort: O(n log n) always, O(n) extra space. Quick sort: O(n log n) average, O(n²) worst case, in-place.
• Java-specific trivia: [Link]() on a primitive array (int[]) uses dual-pivot quicksort and is NOT stable. [Link]() on
an object array (Integer[]) or [Link]() on a List uses a stable, TimSort-based algorithm. A classic Java interview
trick question.

▶recursion-tree
Best channel: Kunal Kushwaha for native-Java coverage. Abdul Bari remains worth watching purely for the
visualizations of merge sort and quick sort's partition scheme — 100% language-independent
intuition.

Phase 4 — Hashing
☐ Hash map / hash set concepts
☐ Collision handling: chaining vs. open addressing
☐ Frequency counting patterns
☐ Two-sum style problems
☐ When hashing beats sorting/searching (and when it doesn't)
☐ Java-specific: the equals() / hashCode() contract

✎ Cheat sheet
 • If a problem needs O(1) lookup and order doesn't matter → HashMap/HashSet.
• If a problem needs "kth smallest," "sorted order," or "range query" → hashing usually doesn't help; reach for sorting, a
heap, or a BST instead.
• Two-sum pattern: store {value: index} while iterating once; check target - arr[i] in the map before inserting the current
element.
• Frequency map + sliding window = most "distinct characters" / "anagram" problems.
• The Java-specific rule interviewers love: if two objects are equal per .equals(), they MUST return the same .hashCode()
— override both together, or custom objects behave unpredictably inside HashMap/HashSet. Also: HashMap's default
load factor is 0.75, and it rehashes once that threshold is crossed.

▶factor,Bestthechannel: Kunal Kushwaha — his hashing/HashMap videos go into the actual Java internals (buckets, load
equals()/hashCode() contract), which matters more in a Java-specific interview.

Phase 5 — Recursion & Backtracking

☐ Recursion fundamentals: base case, call stack
☐ Recursion on arrays/strings
☐ Backtracking framework: choose → explore → un-choose
☐ Subsets, permutations, combinations
☐ N-Queens, Sudoku solver, Rat in a Maze
☐ Word search / path-finding

✎ Cheat sheet
• Backtracking template: for each choice → make choice → recurse → undo choice. Beginners forget the "undo" step
constantly.
• Subsets = include/exclude each element (2ⁿ total). Permutations = swap-based or a used[] boolean array. Combinations
= fix a start index to avoid duplicates.
• Most backtracking problems run in exponential time — that's expected, not a mistake in your solution.

▶most-recommended
Best channel: Pepcoding (Sumit Malik)'s "Recursion & Backtracking" Level 1 and Level 2 playlists — the single
free resource for building recursive intuition in Java, taught entirely in Java from the ground
up.

Phase 6 — Linked Lists

☐ Singly, doubly, circular linked list
☐ Insertion, deletion, traversal, reversal
☐ Fast & slow pointer (Floyd's cycle detection)
☐ Merge two sorted lists
☐ Reverse in groups of k
☐ Detect/remove loop, find middle
 ☐ Flatten a multilevel linked list

✎ Cheat sheet
• A "node" in Java is just an object with a next field referencing another object — no raw pointer arithmetic; the garbage
collector cleans up unreachable nodes automatically.
• Fast/slow pointer: slow moves 1 step, fast moves 2. They meet inside a cycle; fast reaching null means no cycle.
• Finding the middle: same fast/slow trick — when fast hits the end, slow sits at the middle.
• Reversal template: track prev, curr, next — at each step, next = [Link]; [Link] = prev; prev = curr; curr = next;
• Always ask: does this problem need a dummy head node? It removes most of the edge-case headaches around the
list's head.

▶harder
Best channel: Kunal Kushwaha or Pepcoding — both implement this phase natively in Java, including the
"flatten" and "reverse in k-groups" problems.

Phase 7 — Stack & Queue

☐ Array-based and linked-list-based stack
☐ Balanced parentheses, infix-to-postfix, next greater/smaller element
☐ Monotonic stack pattern
☐ Simple queue, circular queue, deque
☐ Priority queue (conceptual)
☐ Queue using stacks and vice versa
☐ Java-specific: ArrayDeque vs. the legacy Stack class

✎ Cheat sheet
• "Next greater/smaller element" almost always means a monotonic stack: push indices, pop while the top violates the
monotonic order.
• Balanced parentheses: push opening brackets; on a closing bracket, check the top matches — a mismatch, or a non-
empty stack at the end, means unbalanced.
• Queue using 2 stacks: push → stack1; pop → if stack2 is empty, dump all of stack1 into stack2, then pop from stack2.
• Use Deque<Integer> stack = new ArrayDeque<>(); instead of the old [Link] class — Stack extends Vector and
is internally synchronized, slower for no benefit in a single-threaded interview context.

▶applies)
Best channel: Aditya Verma's Stack playlist — his pattern-first teaching (recognizing when a monotonic stack
is entirely language-agnostic and maps cleanly onto Java's ArrayDeque.

Phase 8 — Trees
☐ Binary tree basics, traversals (in/pre/post, recursive + iterative)
☐ Level order traversal (BFS)
☐ BST insert/delete/search, validate BST, kth smallest/largest
 ☐ LCA
☐ Balanced trees (AVL/Red-Black — conceptual)
☐ Trie: insert, search, prefix matching
☐ Segment tree, Fenwick tree (BIT)
☐ Java-specific: TreeMap / TreeSet as a ready-made balanced BST

✎ Cheat sheet
• Inorder traversal of a BST = sorted order. Use this to validate a BST in O(n) without extra bounds-checking logic.
• LCA (binary tree, no parent pointers): recurse left and right; if both calls return non-null, the current node is the LCA.
• Trie node: children[26] array (or HashMap<Character, TrieNode>) plus an isEndOfWord flag. Insert/search run in
O(length of word).
• Segment tree: O(n) to build, O(log n) per query/update — reach for it when a problem needs repeated range queries.
• Java gives you a free balanced BST: TreeMap/TreeSet are backed by a red-black tree
internally. .floorKey(), .ceilingKey(), .higherKey(), .lowerKey() solve most "closest value" interview questions without
hand-rolling a balanced tree.

▶AbdulBestBarichannel: Kunal Kushwaha for traversals, BST operations, and LCA — all implemented natively in Java.
stays the pick for the AVL/Red-Black "why balancing matters" conceptual explanation.

Phase 9 — Heaps & Priority Queues

☐ Min-heap, max-heap (array representation)
☐ Heapify, build-heap, heap sort
☐ kth largest/smallest, top-k frequent elements
☐ Merge k sorted lists using a heap
☐ Java-specific: PriorityQueue's default ordering

✎ Cheat sheet
• Parent/child index math (0-indexed array): parent = (i-1)/2, left = 2i+1, right = 2i+2.
• "Kth largest" → a min-heap of size k. "Top-k frequent" → frequency map first, then a heap of size k over the
frequencies.
• Build-heap runs in O(n), not O(n log n) — a common interview trick question regardless of language.
• The single most important Java-specific gotcha in this whole roadmap: [Link] is a min-heap by
default — the OPPOSITE of C++'s std::priority_queue, which defaults to a max-heap. For a max-heap in Java, write new
PriorityQueue<>([Link]()) or supply your own comparator. Also: PriorityQueue doesn't allow null
elements and isn't thread-safe.

▶clearest
Best channel: NeetCode's heap videos, grouped by pattern (top-k, merge-k, two-heaps-for-median) — the
pattern-first breakdown, even though the code is Python. Pair with Kunal Kushwaha's Java-native
PriorityQueue walkthroughs for exact syntax and the min/max-heap gotcha.
Phase 10 — Graphs
☐ Adjacency list vs. matrix (in Java: List<List<Integer>>, or List<List<int[]>> for weighted edges)
☐ BFS, DFS
☐ Cycle detection (directed/undirected)
☐ Topological sort (Kahn's + DFS-based)
☐ Dijkstra, Bellman-Ford, Floyd-Warshall
☐ Prim's, Kruskal's, Union-Find (path compression + rank)
☐ Bridges/articulation points
☐ Kosaraju's/Tarjan's (SCC)
☐ Bipartite check

✎ Cheat sheet
• Choosing a shortest-path algorithm: no negative weights → Dijkstra; negative weights allowed → Bellman-Ford; need
all-pairs shortest paths → Floyd-Warshall.
• Cycle detection: undirected → Union-Find or DFS with parent tracking; directed → DFS with recursion-stack tracking, or
Kahn's algorithm.
• MST: Kruskal's = sort edges + Union-Find (sparse graphs); Prim's = priority queue-driven (dense graphs) — remember
Phase 9's min-heap gotcha applies here too.
• Bipartite check = 2-color the graph via BFS/DFS; hitting a conflict means it isn't bipartite.

▶representation.
Best channel: Kunal Kushwaha's Graphs-in-Java playlist — built end-to-end around Java's List<List<Integer>>
Striver's Graph series is an excellent secondary reference for full algorithmic breadth (including
Kosaraju's/Tarjan's) — the companion site provides Java code alongside the video's C++.

Phase 11 — Dynamic Programming

☐ Fundamentals: overlapping subproblems, optimal substructure, memoization vs. tabulation
☐ 1D DP, 2D DP (grid paths)
☐ Knapsack family (0/1, unbounded, subset sum)
☐ LCS family (LCS, edit distance, longest palindromic subsequence)
☐ LIS (O(n²) and O(n log n))
☐ Matrix Chain Multiplication
☐ DP on strings, DP on trees, bitmask DP

✎ Cheat sheet
• Recognizing DP: the problem asks for min/max/count/possible-or-not, and each choice affects future choices.
• Standard recipe: (1) define the state in words, (2) write the recurrence in terms of smaller states, (3) identify base
cases, (4) memoize top-down first, (5) convert to tabulation.
• 0/1 knapsack recurrence: dp[i][w] = max(dp[i-1][w], val[i] + dp[i-1][w-wt[i]]) if wt[i] <= w, else dp[i-1][w].
• LCS recurrence: characters match → 1 + dp[i-1][j-1]; no match → max(dp[i-1][j], dp[i][j-1]).
 ▶to aBest channel: Aditya Verma's DP playlist, built around a "choice diagram" mapping almost every DP problem
knapsack/LCS/LIS template — entirely pattern-based, translates 1:1 into Java. Prefer Java code already written
out? Striver's DP series and Apna College's DP-in-Java content are both solid native-Java alternatives.

Phase 12 — Greedy Algorithms

☐ When greedy works vs. fails
☐ Activity selection / interval scheduling
☐ Fractional knapsack
☐ Huffman coding (conceptual)
☐ Job sequencing with deadlines
☐ Greedy + graphs overlap (Prim's/Kruskal's)

✎ Cheat sheet
• Greedy works when a problem has the greedy-choice property: a locally optimal choice leads to a globally optimal
solution, usually provable via an exchange argument.
• Interval scheduling: sort by end time, then greedily pick the earliest-ending non-overlapping interval.
• Fractional knapsack: sort by value/weight ratio and fill greedily — unlike 0/1 knapsack, NOT a DP problem.
• If you can construct a counterexample to a greedy approach in under a minute, it's probably a DP problem in disguise.

▶not Best channel: Abdul Bari — his greedy-algorithms playlist covers the proof intuition (why greedy holds here but
there), regardless of language.

Phase 13 — Advanced Topics (placed vs. placed at a high package)

☐ Advanced bit manipulation: subset bitmasking, XOR tricks, counting set bits
☐ Advanced two-pointer/sliding window variants
☐ String algorithms: KMP, Z-algorithm, Rabin-Karp, Manacher's
☐ Advanced number theory: Sieve of Eratosthenes, modular exponentiation/inverse
☐ Segment tree with lazy propagation
☐ Sqrt decomposition (optional, competitive-programming-only depth)
☐ Java-specific: BigInteger/BigDecimal for arbitrary-precision problems

✎ Cheat sheet
• KMP builds a "longest prefix-suffix" (LPS) array to avoid re-scanning on a mismatch — O(n+m) pattern matching.
• Modular exponentiation: compute power(a, b, m) via binary exponentiation — O(log b), not O(b).
• Sieve of Eratosthenes: O(n log log n) to find all primes up to n — always precompute, never trial-divide per query.
• Lazy propagation exists purely to make range updates O(log n) instead of O(n) per update.
• BigInteger/BigDecimal rarely come up in placement-level DSA, but worth knowing if constraints exceed a long's range
— more common in contests than interviews.
 ▶competitive-programming
Best channel: Striver (takeUforward) for the string-algorithm and bit-manipulation playlists. Errichto (a
channel) if pushing into sqrt decomposition and CP-specific depth beyond placements.

Phase 14 — Low-Level Design (LLD)

☐ OOP principles: encapsulation, inheritance, polymorphism, abstraction
☐ SOLID principles
☐ Design patterns: Singleton, Factory, Observer, Strategy
☐ Practice: parking lot, library management system, tic-tac-toe

✎ Cheat sheet
• SOLID in one line each: Single responsibility (one reason to change), Open/closed (extend without modifying), Liskov
substitution (a subclass should be usable wherever its base class is expected), Interface segregation (many small
interfaces beat one large one), Dependency inversion (depend on abstractions, not concrete classes).
• LLD interview approach: (1) clarify requirements/scope out loud, (2) identify the core entities/nouns, (3) define
relationships (has-a/is-a), (4) reach for a design pattern only if it solves an actual problem in the design.
• Singleton = one instance app-wide. Factory = delegate object creation. Observer = one-to-many state-change
notification. Strategy = swap algorithms at runtime.

✎ Why this phase is genuinely easier for you than the C++ track
• You've been writing class-based, object-oriented Java since Day 0 — encapsulation, inheritance, and polymorphism
aren't new vocabulary by now, they're habits you've already built. LLD is less "a new skill" and more "putting a name to
what you've been doing since Phase 0."

▶freeBest channel: Kunal Kushwaha's dedicated LLD/system-design playlist — the most commonly recommended
resource for parking-lot/library-system-style interview questions, and the same creator you likely started with
in Phase 0.

Why Phase 14 sits here: pure-DSA rounds get you through initial screening, but high-package/product-based interview
loops add a separate LLD round. Run this in parallel with DSA during the last two months rather than treating it as an
afterthought.
Part 2B — The Missing Phases
Unchanged in substance, no language dependency.

Phase 15 — Aptitude, Quantitative & Logical Reasoning

Almost every on-campus drive, and a good share of off-campus applications, open with an aptitude test before any DSA
round even begins. Skip this phase and the rest of the roadmap never gets a chance to matter.
☐ Quant: percentages, profit/loss, time-speed-distance, time & work, ratios, averages, simple/compound interest
☐ Logical reasoning: puzzles, seating arrangement, blood relations, syllogisms, series completion
☐ Verbal ability: reading comprehension, sentence correction, para-jumbles
☐ Data interpretation: tables, bar/line/pie charts

✎ Cheat sheet
• Most aptitude tests are negative-marked and time-boxed — practice under a timer from day one, not untimed.
• Time & Work: if A finishes a job in x days, A's one-day work rate is 1/x; combine rates, not raw day-counts.
• Speed/distance: Speed = Distance / Time; relative speed is the sum of speeds for opposite directions, the difference for
the same direction.
• Set aside one week per month (not a full parallel track) starting in month 2 — light, consistent practice, not a 3-4 hour
daily commitment.

▶channel
Best channel: Sandeep Kumar (Quantitative Aptitude) for concept videos, and the PrepInsta website +
combination for company-specific test patterns (TCS NQT, Infosys, and similar).

Phase 16 — CS Fundamentals: OS, DBMS, Computer Networks, OOP Theory

Asked as a standalone round (or folded into technical rounds) at nearly every product-based company, independent of
your DSA performance.
☐ OS: process vs. thread, scheduling algorithms, deadlock (conditions + prevention), memory management,
paging/segmentation, semaphores/mutexes
☐ DBMS: normalization (1NF–3NF, BCNF), ACID properties, indexing, joins, transactions, keys
(primary/foreign/candidate)
☐ Computer Networks: OSI vs. TCP/IP model, TCP vs. UDP, HTTP/HTTPS basics, DNS, common ports
☐ OOP theory: the four pillars in more depth than Phase 14 covers, abstract classes vs. interfaces

✎ Cheat sheet
• Deadlock requires all four conditions at once: mutual exclusion, hold-and-wait, no preemption, circular wait — break
any one and deadlock becomes impossible.
• ACID: Atomicity (all-or-nothing), Consistency (valid state to valid state), Isolation (concurrent transactions don't
interfere), Durability (committed data survives a crash).
• TCP: reliable, connection-oriented, ordered (file transfer, web traffic). UDP: unreliable, connectionless, faster
 (video/voice streaming, gaming).
• Normalization removes redundancy, but over-normalizing hurts read performance — a common interviewer follow-up.

✎ A small bonus for the Java track

• The OOP-theory portion of this phase will feel like revision rather than new material, since you've been applying these
four pillars daily since month one.

▶interview
Best channel: Gate Smashers — still the most widely used free channel for OS/DBMS/CN theory at placement-
depth.

Phase 17 — SQL
Frequently tested standalone (HackerRank SQL, LeetCode Database problems) and often referenced inside DBMS
interview questions.
☐ SELECT, WHERE, GROUP BY, HAVING, ORDER BY
☐ Joins: INNER, LEFT, RIGHT, FULL, SELF
☐ Subqueries, CTEs (WITH clause)
☐ Window functions: RANK, DENSE_RANK, ROW_NUMBER, LAG/LEAD
☐ Aggregate functions: COUNT, SUM, AVG, MIN, MAX

✎ Cheat sheet
• WHERE filters rows before grouping; HAVING filters groups after GROUP BY — this distinction gets asked constantly.
• RANK() skips numbers after ties (1,1,3); DENSE_RANK() doesn't (1,1,2); ROW_NUMBER() ignores ties entirely (1,2,3).
• A self join joins a table to itself, typically for hierarchical data (employee-manager relationships).
• Practice on LeetCode's Database question set — it closely mirrors real interview SQL question style.

▶Analyst
Best channel: Striver (takeUforward)'s SQL playlist covers this exact list in interview-question format; Alex The
if you want a more thorough beginner-to-advanced pass with extra depth.

Phase 18 — Resume, GitHub & LinkedIn

This is what gets you shortlisted before any DSA round even happens.
☐ One-page resume: projects, skills, achievements — cut filler bullet points entirely
☐ 2-3 solid projects with a live demo/GitHub link, and a README explaining the "what" and "why," not just the
tech stack
☐ Quantify impact where possible ("reduced load time by X%" beats "worked on optimization")
☐ A clean, pinned-repo GitHub profile — consistent commit history, no half-finished tutorial-clone repos left public
☐ LinkedIn: a clear headline, summary, and consistent activity — many recruiters source candidates directly from
here
 ✎ Cheat sheet
• Resume rule of thumb: every bullet should answer what you built, what tech, and what measurable outcome — cut
anything that fails this test.
• Don't list a skill you can't defend for 5 minutes of interview questioning — your resume becomes the interviewer's
question map.
• Aim for one project that shows depth (a genuinely non-trivial system) and one that shows breadth (a different
domain/stack) rather than five shallow projects.
• Java-specific angle: since Java's strongest real-world lane is backend/enterprise development, a small Spring Boot REST
API project — backed by a real database, not just CRUD against in-memory data — reads noticeably stronger to
interviewers than a fifth pure-DSA repository.

▶Search
Best channel: No single dominant YouTube channel here — this phase is better served by direct human review.
"SDE resume review [your target companies]" for current examples, or better yet, get a peer or senior to
review it directly.

Phase 19 — HR / Behavioral Round

Many otherwise-strong candidates lose offers here simply because the technical rounds were the only thing they
prepared for.
☐ "Tell me about yourself" — a tight 60-90 second narrative, not a resume readout
☐ STAR method: Situation, Task, Action, Result — structure every behavioral answer this way
☐ Common questions: strengths/weaknesses, why this company, conflict with a teammate, biggest failure, where
do you see yourself in 5 years
☐ Questions to ask the interviewer (always have 2-3 ready — asking none is a visible red flag)
☐ Salary/offer discussion basics

✎ Cheat sheet
• STAR in one line: describe the situation briefly, the task you owned, the action you specifically took, and a measurable
result — most people skip the result and weaken an otherwise good answer.
• "Weakness" questions want a genuine weakness plus a concrete step you're actively taking on it — not a disguised
strength like "I work too hard."
• Research the company's recent product or news before the interview — one specific, genuine reason for "why this
company" consistently outperforms a generic answer.

▶available
Best channel: Exponent — structured STAR-method walkthroughs built specifically for tech interviews, also
as free content on their channel.
Part 3 — Java-First Channel Roster (Reference List)
Use the per-phase table above as your primary guide; treat this as the fallback list if a phase-specific pick doesn't match
your learning style.

Channel Best for

Kunal Kushwaha End-to-end Java DSA + LLD — the spine of this entire Java track

Pepcoding (Sumit Malik) Deep, native-Java problem sets, especially recursion/backtracking

Apna College (Shradha Khapra) Full Hindi+English Java placement bootcamp — a strong alternate teaching style

Best-structured pattern sequencing (A2Z/SDE sheet); videos are C++-narrated,

Striver (takeUforward) but the companion sheet provides Java code and the pattern logic transfers
completely

Abdul Bari Deep conceptual "why" behind algorithms — fully language-agnostic

Aditya Verma Dynamic Programming and Stack patterns specifically, taught pattern-first

Pattern-grouped revision; Python-narrated, but the grouping itself is still the

NeetCode
clearest available

Gate Smashers OS/DBMS/CN theory

GeeksforGeeks (channel + site) Reference/lookup, with direct Java tags on articles and practice problems

Practical advice, unchanged from the original: don't subscribe to all of them and jump around. Pick one concept-teacher
for your first pass through each topic, and one pattern/revision channel for the polishing phase later.

Part 4 — Best Websites to Practice On

No changes here — every major platform accepts Java submissions natively, so your language choice doesn't restrict
where you practice.

Platform Best for Notes

Interview-style problems, product The default for FAANG/product-based prep; also

LeetCode
companies hosts the SQL question set for Phase 17

Strong fit for service-based and many product-

GeeksforGeeks (practice) Concept + practice combined
based Indian companies

Fully supports Java submissions, though most

Codeforces Competitive programming public editorial solutions skew C++; start around
month 4

InterviewBit Guided structured path Fixed curriculum, less decision fatigue

Many companies run online assessments here —

HackerRank Beginner-friendly + assessments + SQL
also good for Phase 17 SQL practice
Platform Best for Notes

Striver's A2Z / TUF+ sheet Curated problem list Layer this on top of the platforms above

Best fallback if you're short on time heading into

NeetCode 150 / Blind 75 High-yield problem sets
month 6

Company-wise aptitude question banks (TCS,

PrepInsta Aptitude test patterns
Infosys, Wipro, etc.) for Phase 15
Part 5 — The 6-Month Schedule
Topics and timing unchanged — Java doesn't shift the calendar.

✎ Target by month 6
• ~450–550 DSA problems solved, one full topic-wise revision pass, 15-20 contests, 5+ mock interviews, an LLD portfolio
of 2-3 systems, plus a finished resume/GitHub/LinkedIn, working CS-fundamentals recall, basic SQL fluency, and
rehearsed HR answers.

Month 1 — Foundations, arrays, strings, searching, sorting, hashing

Week Focus Problems/day Milestone

Comfortable with loops/recursion,

1 Phase 0 + Phase 1 (Java syntax/OOP basics land here too) 2-3 (easy)
reasoning about Big-O

Two-pointer/sliding window feel

2 Phase 2: arrays & strings 3-4 natural; StringBuilder habit is
automatic

Implement merge sort and quick

3 Phase 3: searching & sorting 3-4
sort from memory

Solve 5 random Month 1 problems

4 Phase 4: hashing + Month 1 revision 3-4
cold

Month 2 — Recursion, backtracking, linked lists, stack, queue

Week Focus Problems/day Milestone

Can draw the recursion tree for

5 Phase 5: recursion fundamentals 3
any problem solved

Comfortable with choose-explore-

6 Phase 5: backtracking 2-3
unchoose

Reverse a list and detect a cycle

7 Phase 6: linked lists 3-4
unaided

"Next greater element" and "valid

Phase 7: stack & queue + revision + start Phase 15
8 3-4 parentheses" solved cold, using
(aptitude), 1 hr/week
ArrayDeque

Month 3 — Trees and heaps

Week Focus Problems/day Milestone

All traversals coded iteratively and

9 Binary trees + traversals 3-4
recursively
Week Focus Problems/day Milestone

Comfortable with BST

10 BST + LCA + balanced tree concepts 3 insert/delete/search, plus
TreeMap/TreeSet shortcuts

Trie, segment tree, Fenwick tree + start Phase 16 (OS), 2

11 2-3 Trie implemented from scratch
hrs/week

Comfortable using PriorityQueue

for top-k/merge-k — including
12 Heaps + Month 3 revision 3-4
remembering to flip it to a max-
heap when needed

Month 4 — Graphs (start light contest exposure this month)

Week Focus Problems/day Milestone

BFS and DFS from memory in

13 Graph representation + BFS/DFS 3
under 5 minutes

Topological sort, Dijkstra, Bellman-Ford + Phase 16 Know when to use which shortest-
14 2-3
(DBMS), 2 hrs/week path algorithm

Comfortable with DSU including

15 MST, Union-Find + Phase 17 (SQL) begins, 2 hrs/week 2-3
path compression

Finish a full contest (Java is fully

16 SCC, bridges + revision + first contest 2-3 + 1 contest
accepted on Codeforces)

Month 5 — Dynamic programming, greedy, and consolidation

Week Focus Problems/day Milestone

DP fundamentals + 1D/2D DP + Phase 16 (CN), 2

17 3-4 Set up a DP recurrence unaided
hrs/week

Convert a recursive solution to

18 Knapsack + LCS family 3
tabulation

LIS, DP on strings/trees, bitmask DP + draft resume Attempted a bitmask DP problem

19 2-3
(Phase 18) successfully

Full topic-wise revision pass #2

20 Greedy + Month 5 revision + contest 3 + 1 contest
completed

Month 6 — Advanced topics, LLD, HR prep, and sprint to placement-ready

Week Focus Milestone

Comfortable with 2+ string-matching

Advanced bit manipulation, KMP/Z/Rabin-Karp, sieve + finalize
21 algorithms; resume finalized, ideally with a
resume & GitHub (Phase 18)
small Spring Boot project included
Week Focus Milestone

22 Segment tree w/ lazy propagation + start LLD One LLD system designed end to end

23 NeetCode 150/Blind 75 sprint + 2nd LLD system + LinkedIn cleanup 2 systems designed; problem gaps near zero

Mock interviews (2-3) + HR/behavioral prep (Phase 19), STAR

24 2-3 mocks completed, feedback incorporated
answers drafted

Full final revision + timed problem-solving + aptitude mock tests 10-problem mixed set solved in interview-time
25
(Phase 15) conditions

Placement-ready across DSA + fundamentals +

26 Light revision, rest, mental prep, apply/interview
resume + HR
Part 6 — A Few Things Worth Knowing Before You Start
☐ DSA alone doesn't get you a high package. Phases 15-19 exist precisely because CS fundamentals, aptitude, SQL,
your resume, and the HR round are graded rounds too, not optional side quests.
☐ Consistency beats intensity. Three focused hours daily for six months beats occasional 8-hour weekend binges.
☐ Revise on a schedule, not just once. Each month ends with a dedicated revision week for exactly this reason.
☐ Don't skip the "why." If you can solve a problem but can't explain why your approach works, an interviewer who
tweaks the constraints slightly will expose that gap instantly. Prioritize depth over speed for the first four months,
then flip to speed over depth for months 5-6.
☐ A Java-specific closing thought: Java's verbosity is a feature during interviews, not a flaw. Writing out
HashMap<Integer, Integer> map = new HashMap<>(); instead of a one-word C++ declaration costs a couple of extra
seconds, but it reads completely unambiguously to an interviewer who's watching you type — and in a live
interview, how clearly you communicate matters just as much as whether your logic is correct.
☐ Aptitude, CS fundamentals, and resume work don't need daily 3-4 hour blocks — they're deliberately scheduled
as light, parallel weekly touches (1-2 hrs/week) so they never compete with your core DSA time. They only become
the primary focus once you reach month 6.

✎ Good luck
• Day 0 starts the moment you close this document and open your editor.