Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours

Problems

JAVA DSA
Data Structures & Algorithms — Complete Syllabus with
LeetCode Problems
10 Units | 100+ Problems | Arrays to Graphs to DP | Interview Ready

10 Units 100+ Topics 150+ Hours LeetCode List Job Ready

COURSE OVERVIEW

यह Java DSA का complete syllabus है — Beginners से लेकर Product Company Interviews

तक। हर Unit में concept की detailed explanation है, Java code examples हैं, और
LeetCode problems की list है। इस order में पढ़ो और हर unit के बाद LeetCode
problems ज़रूर solve करो।

Prerequisites After This Course You Can:

Core Java — OOP, Collections, Streams Solve LeetCode Easy & Medium problems
ArrayList, LinkedList, HashMap (Collections Crack TCS, Wipro, Infosys coding rounds
Framework) Clear FAANG screening rounds
Basic Math — Modulo, Powers, Factors Implement any DS from scratch in interview
Recursion Basics (Unit 4 of Core Java)

Unit 1 Complexity Analysis — Big O Notation 6 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

Why Complexity? Code की efficiency measure करते हैं। Time complexity = कितना
time लगेगा। Space complexity = कितनी memory लगेगी।
Big O Notation Worst case performance। O(1) < O(log n) < O(n) < O(n log n) < O(n²) <
O(2ⁿ) < O(n!)
O(1) → HashMap get/put O(log n)→ Binary Search O(n) →
Single loop O(n²) → Nested loops

Time Complexity Loops count करो। Nested loop = multiply। Sequence = add।
Calculate करना for(int i=0;i<n;i++) → O(n) for(int i=0;i<n;i++)
for(int j=0;j<n;j++) → O(n²) for(int i=1;i<n;i*=2) →
O(log n)

Space Complexity Extra memory use। Recursive calls stack space भी count होती है।
int[] arr = new int[n] → O(n) space int x = 5;

Java DSA Syllabus with LeetCode Problems | Page 1

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
→ O(1) space

Best/Worst/Average Best case (Ω), Average (Θ), Worst (O). Interviews में हमेशा Worst
Case case बताओ।

Unit 2 Arrays & Strings — Foundation 16 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

Array Basics in Java Fixed size, same type। Index 0 से start। Access O(1), Search O(n),
Insert/Delete O(n)।
int[] arr = {5,3,1,4,2}; [Link](arr); // O(n
log n) [Link](arr,0); // O(n) int len =
[Link];

Two Pointer Technique Array के दोनों ends से pointers चलाओ। Sorted array problems
में use होता है।
int l=0, r=[Link]-1; while(l < r) { if(arr[l]
+arr[r]==target) return true; else if(arr[l]
+arr[r]<target) l++; else r--; }
LeetCode: Two Sum II, Container With Most Water

Sliding Window Fixed या variable size window को array में slide करो।
// Fixed window of size k: int sum=0; for(int i=0;i<k;i++)
sum+=arr[i]; for(int i=k;i<n;i++) { sum += arr[i]-arr[i-
k]; max = [Link](max,sum); }
LeetCode: Max Sum Subarray of size K

Prefix Sum पहले prefix sum array बनाओ, फिर range sum O(1) में निकालो।
int[] pre = new int[n+1]; for(int i=0;i<n;i++)
pre[i+1]=pre[i]+arr[i]; // Sum from l to r: int sum =
pre[r+1] - pre[l];
LeetCode: Subarray Sum Equals K

Kadane's Algorithm Maximum subarray sum। DP + Array।

int maxSum=arr[0], curr=arr[0]; for(int i=1;i<n;i++)
{ curr = [Link](arr[i], curr+arr[i]); maxSum =
[Link](maxSum,curr); }
LeetCode: #53 Maximum Subarray

String Methods in Java charAt(), substring(), indexOf(), toCharArray(), split(), StringBuilder।

String s = "hello"; char[] chars = [Link]();
StringBuilder sb = new StringBuilder(s);
[Link]().toString(); // "olleh"

String + HashMap Characters ki frequency count करने के लिए HashMap use करो।
(Frequency) Map<Character,Integer> freq = new HashMap<>(); for(char c :
[Link]()) [Link](c, 1, Integer::sum);
LeetCode: Valid Anagram, Group Anagrams

Two Sum using O(n) solution। Complement store करो।

HashMap Map<Integer,Integer> map = new HashMap<>(); for(int
i=0;i<[Link];i++) { if([Link](target-
nums[i])) return new int[]{[Link](target-nums[i]),i};
[Link](nums[i],i); }
LeetCode: #1 Two Sum

Unit 2 — LeetCode Problems

Java DSA Syllabus with LeetCode Problems | Page 2

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems

# Problem Name Difficulty Topic Tag

#1 Two Sum Easy HashMap
#121 Best Time to Buy and Sell Stock Easy Array
#53 Maximum Subarray Easy Kadane's Algorithm
#26 Remove Duplicates from Sorted Array Easy Two Pointer
#167 Two Sum II - Input Array Is Sorted Medium Two Pointer
#15 3Sum Medium Two Pointer
#11 Container With Most Water Medium Two Pointer
#238 Product of Array Except Self Medium Prefix Sum
#560 Subarray Sum Equals K Medium HashMap + Prefix
#42 Trapping Rain Water Hard Two Pointer

Unit 3 Linked List — Singly, Doubly, Circular 14 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

Node Class (Java) Linked List का building block।
class ListNode { int val; ListNode next; ListNode(int
val) { [Link] = val; } }

Singly Linked List Insert at head O(1), Insert at tail O(n), Delete O(n), Search O(n), Traverse
Operations O(n)।
// Insert at head: public void addFirst(int val)
{ ListNode node = new ListNode(val); [Link] = head;
head = node; }

Fast & Slow Pointer दो pointers — एक 1 step, दूसरा 2 steps। Cycle detect, middle find
(Floyd's) करने के लिए।
ListNode slow=head, fast=head; while(fast!=null &&
[Link]!=null) { slow=[Link]; fast=[Link];
if(slow==fast) return true; // cycle! } return false;
LeetCode: Linked List Cycle

Reverse Linked List तीन pointers — prev, curr, next।

ListNode prev=null, curr=head; while(curr!=null)
{ ListNode next=[Link]; [Link]=prev; prev=curr;
curr=next; } return prev; // new head
LeetCode: #206 Reverse Linked List

Merge Two Sorted Lists Dummy node trick।

ListNode dummy=new ListNode(0), cur=dummy; while(l1!=null &&
l2!=null) { if([Link]<=[Link]) { [Link]=l1;
l1=[Link]; } else { [Link]=l2; l2=[Link]; }
cur=[Link]; } [Link] = l1!=null?l1:l2; return
[Link];
LeetCode: #21 Merge Two Sorted Lists

Doubly Linked List prev और next दोनों pointers। Bidirectional traverse। Java LinkedList
doubly linked है।
class DLLNode { int val; DLLNode prev, next; }

Java DSA Syllabus with LeetCode Problems | Page 3

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
Unit 3 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#206 Reverse Linked List Easy Linked List
#21 Merge Two Sorted Lists Easy Linked List
#141 Linked List Cycle Easy Fast & Slow Pointer
#876 Middle of the Linked List Easy Fast & Slow Pointer
#19 Remove Nth Node From End Medium Two Pointer
#2 Add Two Numbers Medium Linked List
#143 Reorder List Medium Linked List
#23 Merge K Sorted Lists Hard Heap + Linked List

Unit 4 Stack & Queue 12 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

Stack in Java LIFO (Last In First Out)। Java में ArrayDeque use करो Stack class
की जगह।
Deque<Integer> stack = new ArrayDeque<>();
[Link](10); // add top [Link](); // view top
(don't remove) [Link](); // remove top
[Link]();

Queue in Java FIFO (First In First Out)।

Queue<Integer> queue = new LinkedList<>();
[Link](10); // add rear [Link](); // view front
[Link](); // remove front

Monotonic Stack Stack जो sorted order maintain करे। Next Greater Element जैसे
problems।
// Next Greater Element: int[] res = new int[n];
Deque<Integer> stack = new ArrayDeque<>(); for(int i=n-
1;i>=0;i--) { while(![Link]() &&
[Link]()<=nums[i]) [Link](); res[i] =
[Link]()?-1:[Link](); [Link](nums[i]); }
LeetCode: Next Greater Element

Valid Parentheses Stack का classic problem।

Map<Character,Character> map =
[Link](')','(',']','[','}','{'); Deque<Character> stack =
new ArrayDeque<>(); for(char c : [Link]())
{ if("([{".indexOf(c)>=0) [Link](c); else
if([Link]()||[Link]()!=[Link](c)) return false; }
return [Link]();
LeetCode: #20 Valid Parentheses

Deque (Double Ended दोनों ends से add/remove। Sliding window maximum के लिए
Queue) perfect।
Deque<Integer> deque = new ArrayDeque<>(); // Front:
[Link](x); [Link](); [Link](); //
Rear: [Link](x); [Link](); [Link]();
LeetCode: Sliding Window Maximum

Priority Queue (Heap) Min Heap by default। Max Heap for [Link]()।

Java DSA Syllabus with LeetCode Problems | Page 4

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
// Min Heap: PriorityQueue<Integer> minH = new
PriorityQueue<>(); // Max Heap: PriorityQueue<Integer> maxH
= new PriorityQueue<>([Link]());
[Link](5); [Link](1); [Link](3); [Link](); //
1 (minimum)
LeetCode: Kth Largest Element

Unit 4 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#20 Valid Parentheses Easy Stack
#225 Implement Stack using Queues Easy Stack/Queue
#155 Min Stack Medium Stack
#215 Kth Largest Element in Array Medium Heap
#239 Sliding Window Maximum Hard Deque
#84 Largest Rectangle in Histogram Hard Monotonic Stack

Unit 5 Recursion & Backtracking 14 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

Recursion Template Base case + Recursive case। हर recursive call stack frame बनाती
है।
// Template: returnType solve(params) { // Base case
if(baseCondition) return baseValue; // Recursive case
return solve(smallerProblem); }

Recursion Tree हर call को tree की तरह visualize करो। Helps understand time
complexity।
fibonacci(4) ├── fibonacci(3) │ ├── fibonacci(2) │ └──
fibonacci(1) └── fibonacci(2)

Merge Sort Divide & Conquer। O(n log n) time, O(n) space।
void mergeSort(int[] arr, int l, int r) { if(l>=r) return;
int mid = l+(r-l)/2; mergeSort(arr,l,mid);
mergeSort(arr,mid+1,r); merge(arr,l,mid,r); // merge two
halves }
LeetCode: Sort Array, Merge Intervals

Quick Sort Average O(n log n), Worst O(n²)। In-place, no extra space।
void quickSort(int[] arr, int l, int r) { if(l>=r) return;
int pivot = partition(arr,l,r); quickSort(arr,l,pivot-1);
quickSort(arr,pivot+1,r); }

Backtracking Template सभी possibilities explore करो, invalid को prune करो।

void backtrack(current, choices) { if(baseCase)
{ addToResult(current); return; } for(choice : choices) {
if(isValid(choice)) { makeChoice(choice);
backtrack(current+choice, remaining);
undoChoice(choice); // BACKTRACK } } }

Subsets All subsets generate करो।

List<List<Integer>> res = new ArrayList<>(); void

Java DSA Syllabus with LeetCode Problems | Page 5

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
backtrack(int start, List<Integer> curr) { [Link](new
ArrayList<>(curr)); for(int i=start;i<[Link];i++) {
[Link](nums[i]); backtrack(i+1,curr);
[Link]([Link]()-1); // undo } }
LeetCode: #78 Subsets

Permutations All permutations generate करो।

void backtrack(List<Integer> curr, boolean[] used)
{ if([Link]()==[Link]){[Link](new
ArrayList<>(curr));return;} for(int i=0;i<[Link];i++)
{ if(used[i]) continue; used[i]=true;
[Link](nums[i]); backtrack(curr,used);
used[i]=false; [Link]([Link]()-1); } }
LeetCode: #46 Permutations

N-Queens Classic backtracking। Row by row queens place करो।

void solve(int row, boolean[] cols, boolean[] d1, boolean[]
d2) { if(row==n) { addSolution(); return; } for(int
col=0;col<n;col++) { if(cols[col]||d1[row-col+n]||
d2[row+col]) continue; place queen at (row,col);
solve(row+1,...); remove queen; } }
LeetCode: #51 N-Queens

Unit 5 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#78 Subsets Medium Backtracking
#46 Permutations Medium Backtracking
#77 Combinations Medium Backtracking
#39 Combination Sum Medium Backtracking
#79 Word Search Medium Backtracking + DFS
#51 N-Queens Hard Backtracking
#37 Sudoku Solver Hard Backtracking

Unit 6 Trees — Binary Tree, BST, AVL 18 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

TreeNode Class Binary tree का node।
class TreeNode { int val; TreeNode left, right;
TreeNode(int val) { [Link] = val; } }

Tree Traversals Inorder (L-Root-R), Preorder (Root-L-R), Postorder (L-R-Root), Level

Order (BFS)।
// Inorder (recursive): void inorder(TreeNode root)
{ if(root==null) return; inorder([Link]);
[Link]([Link]+" "); inorder([Link]); }

Level Order Traversal Queue use करके level by level traverse।

(BFS) List<List<Integer>> res = new ArrayList<>(); Queue<TreeNode>
q = new LinkedList<>(); if(root!=null) [Link](root);
while(![Link]()) { int size=[Link](); List<Integer>
level=new ArrayList<>(); for(int i=0;i<size;i++)

Java DSA Syllabus with LeetCode Problems | Page 6

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
{ TreeNode node=[Link](); [Link]([Link]);
if([Link]!=null) [Link]([Link]); if([Link]!
=null) [Link]([Link]); } [Link](level); }
LeetCode: #102 Binary Tree Level Order

Max Depth of Binary Recursive DFS।

Tree int maxDepth(TreeNode root) { if(root==null) return 0;
return 1+[Link](maxDepth([Link]),
maxDepth([Link])); }
LeetCode: #104 Max Depth

Binary Search Tree Left < Root < Right। Search, Insert, Delete O(log n) avg।
(BST) TreeNode search(TreeNode root, int key) { if(root==null ||
[Link]==key) return root; if(key<[Link]) return
search([Link],key); return search([Link],key); }
LeetCode: #700 Search in BST

Lowest Common Two nodes का LCA find करो।

Ancestor TreeNode lca(TreeNode root, TreeNode p, TreeNode q)
{ if(root==null||root==p||root==q) return root; TreeNode
left=lca([Link],p,q); TreeNode
right=lca([Link],p,q); if(left!=null&&right!=null)
return root; return left!=null?left:right; }
LeetCode: #236 LCA of Binary Tree

Path Sum Root से leaf तक path में target sum है?

boolean hasPathSum(TreeNode root, int target)
{ if(root==null) return false;
if([Link]==null&&[Link]==null) return
[Link]==target; return hasPathSum([Link],target-
[Link]) || hasPathSum([Link],target-
[Link]); }
LeetCode: #112 Path Sum

Diameter of Binary Tree Longest path between any two nodes।

int diameter=0; int dfs(TreeNode node) { if(node==null)
return 0; int l=dfs([Link]), r=dfs([Link]);
diameter=[Link](diameter,l+r); return 1+[Link](l,r); }
LeetCode: #543 Diameter

Validate BST BST valid है या नहीं।

boolean isValid(TreeNode root, long min, long max)
{ if(root==null) return true; if([Link]<=min||
[Link]>=max) return false; return
isValid([Link],min,[Link]) &&
isValid([Link],[Link],max); }
LeetCode: #98 Validate BST

Unit 6 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#104 Maximum Depth of Binary Tree Easy DFS
#226 Invert Binary Tree Easy DFS
#112 Path Sum Easy DFS
#102 Binary Tree Level Order Traversal Medium BFS
#543 Diameter of Binary Tree Easy DFS
#236 LCA of Binary Tree Medium DFS

Java DSA Syllabus with LeetCode Problems | Page 7

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
#98 Validate Binary Search Tree Medium BST
#297 Serialize and Deserialize Binary Tree Hard BFS/DFS

Unit 7 Graphs — BFS, DFS, Shortest Path 18 Hrs

Topic / Data Structure Details, Java Code & LeetCode Problems

Graph Representation Adjacency List (sparse graphs), Adjacency Matrix (dense)। Java में
List<List<Integer>> use करो।
// Adjacency List: List<List<Integer>> graph = new
ArrayList<>(); for(int i=0;i<n;i++) [Link](new
ArrayList<>()); [Link](u).add(v); // undirected:
[Link](v).add(u);

BFS — Breadth First Queue use करो। Shortest path (unweighted), Level order।
Search void bfs(int start, List<List<Integer>> graph) { boolean[]
visited = new boolean[n]; Queue<Integer> q = new
LinkedList<>(); [Link](start); visited[start]=true;
while(![Link]()) { int node=[Link](); for(int nei
: [Link](node)) { if(!visited[nei])
{ visited[nei]=true; [Link](nei); }
} } }
LeetCode: #200 Number of Islands

DFS — Depth First Stack (iterative) या Recursion। Connected components, cycle

Search detection।
void dfs(int node, boolean[] visited, List<List<Integer>>
graph) { visited[node]=true; for(int nei :
[Link](node)) if(!visited[nei])
dfs(nei,visited,graph); }
LeetCode: #133 Clone Graph

Number of Islands Grid पर BFS/DFS। Classic connected components।

// Grid को graph मानो: int islands=0; for(int i=0;i<rows;i+
+) for(int j=0;j<cols;j++) if(grid[i][j]=='1')
{ dfs(grid,i,j); islands++; } void dfs(char[][] g,int i,int
j) { if(i<0||i>=[Link]||j<0||j>=g[0].length||g[i][j]!
='1') return; g[i][j]='0'; // mark visited dfs(g,i+1,j);
dfs(g,i-1,j); dfs(g,i,j+1); dfs(g,i,j-1); }
LeetCode: #200 Number of Islands

Dijkstra's Algorithm Weighted graph में shortest path। Priority Queue use करो।
int[] dist = new int[n];
[Link](dist,Integer.MAX_VALUE); dist[src]=0;
PriorityQueue<int[]> pq = new
PriorityQueue<>([Link](a->a[1]));
[Link](new int[]{src,0}); while(![Link]()) { int[]
cur=[Link](); for(int[] edge:[Link](cur[0])) { int
newDist=dist[cur[0]]+edge[1]; if(newDist<dist[edge[0]])
{ dist[edge[0]]=newDist; [Link](new int[]
{edge[0],newDist}); } } }
LeetCode: Network Delay Time

Topological Sort (Kahn's DAG की ordering। In-degree count करो।

BFS) int[] inDegree = new int[n]; for each edge (u,v):
inDegree[v]++; Queue<Integer> q = new LinkedList<>();
for(int i=0;i<n;i++) if(inDegree[i]==0) [Link](i); while(!
[Link]()) { int node=[Link](); // add to result
for(int nei:[Link](node)) if(--inDegree[nei]==0)
[Link](nei); }

Java DSA Syllabus with LeetCode Problems | Page 8

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
LeetCode: #207 Course Schedule

Union Find (Disjoint Set) Connected components quickly find करो।

int[] parent = new int[n]; int[] rank = new int[n]; void
init() { for(int i=0;i<n;i++) parent[i]=i; } int find(int x)
{ return parent[x]==x?x:(parent[x]=find(parent[x])); } void
union(int x,int y) { int px=find(x),py=find(y);
if(px==py) return; if(rank[px]<rank[py]) parent[px]=py;
else if(rank[px]>rank[py]) parent[py]=px; else
{ parent[py]=px; rank[px]++; } }
LeetCode: #684 Redundant Connection

Unit 7 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#200 Number of Islands Medium BFS/DFS
#133 Clone Graph Medium BFS/DFS
#207 Course Schedule Medium Topological Sort
#210 Course Schedule II Medium Topological Sort
#743 Network Delay Time Medium Dijkstra
#684 Redundant Connection Medium Union Find
#127 Word Ladder Hard BFS
#269 Alien Dictionary Hard Topological Sort

Unit 8 Dynamic Programming (DP) 20 Hrs

DP = Recursion + Memoization। हर DP problem में: 1. Recursive solution लिखो 2.

Memoization add करो (Top-Down) 3. या Tabulation (Bottom-Up) में convert करो।

Topic / Data Structure Details, Java Code & LeetCode Problems

DP Template तीन steps हमेशा follow करो।
// Step 1: Recursive (brute force) // Step 2: + Memoization
(HashMap या int[]) // Step 3: Bottom-up Tabulation

Fibonacci (Memoization) Classic DP starting point।

// Top-Down Memoization: int[] memo = new int[n+1]; int
fib(int n) { if(n<=1) return n; if(memo[n]!=0) return
memo[n]; return memo[n] = fib(n-1)+fib(n-2); } // Bottom-
Up: int[] dp = new int[n+1]; dp[0]=0; dp[1]=1; for(int
i=2;i<=n;i++) dp[i]=dp[i-1]+dp[i-2];

Climbing Stairs n steps, एक बार 1 या 2 steps। Fibonacci pattern।

int climbStairs(int n) { if(n<=2) return n; int a=1,b=2;
for(int i=3;i<=n;i++) { int c=a+b; a=b; b=c; } return b; }
LeetCode: #70 Climbing Stairs

0/1 Knapsack Item include करें या नहीं। 2D DP।

// dp[i][w] = max value with i items, weight limit w for(int
i=1;i<=n;i++) for(int w=0;w<=W;w++) { dp[i][w]=dp[i-1]

Java DSA Syllabus with LeetCode Problems | Page 9

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
[w]; // don't take if(wt[i-1]<=w) dp[i]
[w]=[Link](dp[i][w],val[i-1]+dp[i-1][w-wt[i-1]]); // take
}

Longest Common Two strings में common subsequence।

Subsequence (LCS) // dp[i][j] = LCS length of s1[0..i] and s2[0..j] for(int
i=1;i<=m;i++) for(int j=1;j<=n;j++) { if([Link](i-
1)==[Link](j-1)) dp[i][j]=1+dp[i-1][j-1]; else dp[i]
[j]=[Link](dp[i-1][j],dp[i][j-1]); }
LeetCode: #1143 LCS

Coin Change (Min Coins) Minimum coins to make amount।

int[] dp = new int[amount+1];
[Link](dp,Integer.MAX_VALUE); dp[0]=0; for(int
coin:coins) for(int i=coin;i<=amount;i++) if(dp[i-
coin]!=Integer.MAX_VALUE) dp[i]=[Link](dp[i],dp[i-
coin]+1);
LeetCode: #322 Coin Change

Longest Increasing Array में longest increasing subsequence।

Subsequence (LIS) int[] dp = new int[n]; [Link](dp,1); for(int i=1;i<n;i+
+) for(int j=0;j<i;j++) if(nums[j]<nums[i])
dp[i]=[Link](dp[i],dp[j]+1); return
[Link](dp).max().getAsInt();
LeetCode: #300 LIS

House Robber Adjacent houses rob नहीं कर सकते।

int rob(int[] nums) { int prev2=0, prev1=0; for(int
num:nums) { int curr=[Link](prev1,prev2+num);
prev2=prev1; prev1=curr; } return prev1; }
LeetCode: #198 House Robber

Edit Distance String s को t में convert करने के minimum operations।

for(int i=1;i<=m;i++) for(int j=1;j<=n;j++)
{ if([Link](i-1)==[Link](j-1)) dp[i][j]=dp[i-1][j-
1]; else dp[i][j]=1+[Link](dp[i-1][j-1],[Link](dp[i-
1][j],dp[i][j-1])); }
LeetCode: #72 Edit Distance

Unit 8 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#70 Climbing Stairs Easy DP - 1D
#198 House Robber Medium DP - 1D
#322 Coin Change Medium DP - Unbounded Knapsack
#300 Longest Increasing Subsequence Medium DP
#1143 Longest Common Subsequence Medium DP - 2D
#416 Partition Equal Subset Sum Medium DP - 0/1 Knapsack
#72 Edit Distance Hard DP - 2D
#312 Burst Balloons Hard DP - Interval

Unit 9 Sorting, Searching & Binary Search 12 Hrs

Java DSA Syllabus with LeetCode Problems | Page 10

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems
Topic / Data Structure Details, Java Code & LeetCode Problems
Sorting Algorithms Bubble O(n²), Selection O(n²), Insertion O(n²), Merge O(n log n), Quick
Summary O(n log n) avg, Heap O(n log n)। Java [Link]() = TimSort = O(n log
n)।
int[] arr = {5,3,1,4,2}; [Link](arr); // TimSort //
Custom sort: Integer[] a = {5,3,1}; [Link](a,
[Link]());

Binary Search Template Sorted array में O(log n) search।

int binarySearch(int[] arr, int target) { int l=0,
r=[Link]-1; while(l<=r) { int mid=l+(r-l)/2; //
overflow safe! if(arr[mid]==target) return mid; else
if(arr[mid]<target) l=mid+1; else r=mid-1; } return
-1; }
LeetCode: #704 Binary Search

Binary Search on Answer Answer को binary search करो। Feasibility check function लिखो।
// Pattern: "Find minimum X such that condition(X) is true"
int l=min_val, r=max_val; while(l<r) { int mid=l+(r-l)/2;
if(isValid(mid)) r=mid; // try smaller else l=mid+1;
// need larger } return l;
LeetCode: Koko Eating Bananas

Search in Rotated Sorted Rotation handle करना।

Array int search(int[] nums, int target) { int
l=0,r=[Link]-1; while(l<=r) { int mid=l+(r-l)/2;
if(nums[mid]==target) return mid; if(nums[l]<=nums[mid])
{ // left sorted if(target>=nums[l]&&target<nums[mid])
r=mid-1; else l=mid+1; } else { // right sorted
if(target>nums[mid]&&target<=nums[r]) l=mid+1; else
r=mid-1; } } return -1; }
LeetCode: #33 Search in Rotated Array

Find Peak Element Peak = element greater than neighbors।

int findPeakElement(int[] nums) { int l=0,r=[Link]-1;
while(l<r) { int mid=l+(r-l)/2;
if(nums[mid]>nums[mid+1]) r=mid; else l=mid+1; }
return l; }
LeetCode: #162 Find Peak Element

Unit 9 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#704 Binary Search Easy Binary Search
#374 Guess Number Higher or Lower Easy Binary Search
#33 Search in Rotated Sorted Array Medium Binary Search
#153 Find Minimum in Rotated Sorted Array Medium Binary Search
#162 Find Peak Element Medium Binary Search
#875 Koko Eating Bananas Medium Binary Search on Answer
#4 Median of Two Sorted Arrays Hard Binary Search

Unit 10 HashMap, Heap, Trie & Miscellaneous 10 Hrs

Java DSA Syllabus with LeetCode Problems | Page 11

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems

Topic / Data Structure Details, Java Code & LeetCode Problems

HashMap Patterns Frequency count, index store, complement find।
// Top K Frequent Elements: Map<Integer,Integer> freq = new
HashMap<>(); for(int n:nums) [Link](n,1,Integer::sum);
PriorityQueue<Integer> heap = new PriorityQueue<>((a,b)-
>[Link](b)-[Link](a)); [Link]([Link]()); int[]
result = new int[k]; for(int i=0;i<k;i++)
result[i]=[Link]();
LeetCode: #347 Top K Frequent

Trie Data Structure Prefix-based string storage। Search O(L), Insert O(L) where L=word
length।
class TrieNode { TrieNode[] children = new TrieNode[26];
boolean isEnd; } class Trie { TrieNode root = new
TrieNode(); void insert(String word) { TrieNode
node=root; for(char c:[Link]()) { int
idx=c-'a'; if([Link][idx]==null)
[Link][idx]=new TrieNode();
node=[Link][idx]; } [Link]=true; } }
LeetCode: #208 Implement Trie

Heap Patterns Top K problems, median finding, priority-based processing।

// Find Kth Largest: PriorityQueue<Integer> minHeap = new
PriorityQueue<>(); for(int num:nums) { [Link](num);
if([Link]()>k) [Link](); } return
[Link](); // Kth largest
LeetCode: #215 Kth Largest

Sliding Window Variable window + HashMap combination।

(Advanced) // Longest Substring Without Repeating:
Map<Character,Integer> map = new HashMap<>(); int max=0,
l=0; for(int r=0;r<[Link]();r++) { char c=[Link](r);
if([Link](c)) l=[Link](l,[Link](c)+1);
[Link](c,r); max=[Link](max,r-l+1); } return max;
LeetCode: #3 Longest Substring

Bit Manipulation XOR, AND, OR tricks।

// Single Number (all others appear twice): int result=0;
for(int n:nums) result^=n; // XOR cancels pairs return
result; // Count set bits: [Link](n); // Check
power of 2: (n&(n-1))==0
LeetCode: #136 Single Number

Unit 10 — LeetCode Problems

# Problem Name Difficulty Topic Tag

#3 Longest Substring Without Repeating Medium Sliding Window
#347 Top K Frequent Elements Medium Heap + HashMap
#208 Implement Trie Medium Trie
#136 Single Number Easy Bit Manipulation
#295 Find Median from Data Stream Hard Two Heaps
#76 Minimum Window Substring Hard Sliding Window

Java DSA Syllabus with LeetCode Problems | Page 12

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems

Java DSA Syllabus with LeetCode Problems | Page 13

Java DSA Complete Syllabus — 10 Units + 100+ LeetCode 10 Units | 150+ Hours
Problems

6-MONTH DSA STUDY PLAN

Month Duration Topics LeetCode Target
Month 1 4 weeks Big O + Arrays + Strings + 20 Easy problems
Two Pointer + Sliding
Window
Month 2 4 weeks Linked List + Stack + Queue 20 Easy + 10 Medium
+ Recursion Basics
Month 3 4 weeks Trees (BT + BST) + 10 Easy + 20 Medium
Backtracking
Month 4 4 weeks Graphs (BFS + DFS + 20 Medium problems
Dijkstra + TopSort)
Month 5 4 weeks Dynamic Programming (1D + 15 Medium + 5 Hard
2D + Classic problems)
Month 6 4 weeks Binary Search + Heap + Trie Revision + 20 Mixed
+ Mock Interviews

Daily Routine: सुबह 1 Theory पढ़ो → दोपहर 1-2 LeetCode Problems solve करो → रात
को solution review करो। Minimum 1 problem रोज़ → 180 problems in 6 months = Job
Ready!

Consistency Beats Intensity! Daily 1 Problem = 6 Month Job Ready!

Java DSA Syllabus with LeetCode Problems | Page 14