Data Structures and Algorithms using Java

You can write, compile, and run object-oriented Java programs using core syntax and the Collections Framework.

1. Variables, data types, operators and fast I/O in Java180 min
   • Scanner and BufferedReader
   • primitive vs reference types
   • bitwise operators
   • String pool mechanics
2. Control flow, loops and methods180 min
   • enhanced for-loop
   • switch expressions
   • method overloading
   • pass-by-value semantics
3. Object-oriented programming: classes, objects, inheritance, polymorphism240 min
   • abstract classes
   • interfaces
   • method overriding
   • encapsulation best practices
4. The Java Collections Framework: List, Set, Map and Queue240 min
   • ArrayList vs LinkedList
   • HashSet vs TreeSet
   • HashMap internal hashing
   • Queue and Deque interfaces
5. Generics, wrapper classes and IDE setup (IntelliJ / Eclipse)180 min
   • bounded type parameters
   • autoboxing
   • IntelliJ debugger breakpoints
   • Maven project structure

Hands-on project: Implement a command-line inventory tracker using ArrayList, HashMap, and custom Java classes with robust exception handling.

You can rigorously evaluate time and space complexity using Big-O notation to justify architectural and algorithmic choices.

1. Why complexity matters in coding interviews90 min
   • hardware constraints
   • scalability limits
   • worst-case performance
   • profiling basics
2. Big-O, Big-Theta and Big-Omega notation120 min
   • mathematical definitions
   • upper bounds
   • tight bounds
   • asymptotic dominance
3. Best, average and worst case analysis90 min
   • probabilistic analysis
   • amortized complexity
   • input distributions
   • linear search bounds
4. Analyzing loops, recursion and recurrence relations120 min
   • Master Theorem
   • recursion tree method
   • substitution method
   • nested loop counting
5. Space complexity and in-place algorithms90 min
   • call stack memory
   • auxiliary space
   • heap vs stack allocation
   • garbage collection impact

Hands-on project: Benchmark iterative versus recursive sorting implementations using System.nanoTime() and plot growth rates.

You can solve linear data structure problems efficiently using sliding windows, prefix sums, and two-pointer techniques.

1. Array traversal, rotation and in-place operations180 min
   • matrix rotation
   • array reversal algorithm
   • cyclic sort
   • in-place rearrangement
2. The two-pointer technique180 min
   • opposite ends convergence
   • slow and fast pointers
   • sorted array searches
   • container with most water
3. Sliding window patterns (fixed and variable size)240 min
   • maximum sum subarray
   • longest substring without repeating characters
   • minimum window substring
   • deque window maximum
4. Prefix sums and difference arrays180 min
   • range sum queries
   • equilibrium index
   • subarrays equal to k
   • range update operations
5. Kadane's algorithm and the Dutch National Flag problem180 min
   • maximum subarray sum
   • three-way partitioning
   • circular subarray sum
   • state machine approach
6. String manipulation and common interview string problems240 min
   • StringBuilder efficiency
   • anagram detection
   • palindrome validation
   • string compression

Hands-on project: Build an algorithmic service that processes streaming log files to detect anomalies using sliding window aggregates.

You can implement classic sorting algorithms and apply binary search across monotonic search spaces.

1. Linear search and binary search120 min
   • iterative binary search
   • recursive binary search
   • integer overflow prevention
   • search space reduction
2. Binary search on the answer180 min
   • capacity to ship packages
   • koko eating bananas
   • painters partition problem
   • monotonic predicates
3. Bubble, selection and insertion sort120 min
   • adaptive sorting
   • stability analysis
   • swap counters
   • small dataset optimization
4. Merge sort and quick sort with complexity analysis240 min
   • divide and conquer
   • pivot selection strategies
   • randomized quick sort
   • worst-case mitigation
5. Counting sort, radix sort and heap sort180 min
   • non-comparison sorting
   • digit bucket distribution
   • in-place heap construction
   • bounded key ranges
6. Arrays.sort, Collections.sort and custom comparators120 min
   • Dual-Pivot Quicksort
   • TimSort algorithm
   • Comparator interface
   • Comparable contract

Hands-on project: Implement a custom generic sorting utility that switches between Merge Sort and Insertion Sort based on partition size.

You can solve combinatorial exploration problems using recursive state spaces and backtracking pruning.

1. Recursion fundamentals and the call stack120 min
   • base case design
   • activation records
   • head vs tail recursion
   • stack overflow debugging
2. Subsets, permutations and combinations180 min
   • power set generation
   • duplicate elimination
   • lexicographical ordering
   • backtracking template
3. N-Queens and the Sudoku solver180 min
   • state constraints
   • diagonal tracking
   • board validation
   • board state rollback
4. Rat in a maze and word search120 min
   • grid traversal
   • visited state tracking
   • depth-limited search
   • string matching paths
5. Pruning and backtracking optimization120 min
   • dead-end detection
   • memoized constraints
   • branch-and-bound heuristic
   • search space reduction

Hands-on project: Develop a multi-threaded Sudoku and constraint satisfaction puzzle validator using backtracking.

You can manipulate pointer-based linear structures to perform in-place reversals, cycle detections, and merges.

1. Singly, doubly and circular linked lists120 min
   • node reference allocation
   • sentinel nodes
   • memory overhead
   • pointer update safety
2. Insertion, deletion and traversal120 min
   • head insertion
   • tail deletion
   • index-based traversal
   • edge cases for empty lists
3. Reversal: iterative and recursive120 min
   • three-pointer iterative swap
   • recursive tail reversal
   • sublist reversal
   • k-group reversal
4. Fast and slow pointers: cycle detection (Floyd's algorithm)180 min
   • tortoise and hare
   • cycle start node finding
   • happy number problem
   • middle element extraction
5. Merge, sort, palindrome and intersection problems180 min
   • merge two sorted lists
   • palindrome linked list check
   • intersection point finding
   • reorder list pattern

Hands-on project: Build an LRU Cache data structure backed by a custom doubly linked list and a HashMap in O(1) time.

You can solve expression evaluation and span problems using stacks, queues, and monotonic structures.

1. Stack implementation and applications120 min
   • array-backed stack
   • linked-list stack
   • push/pop amortized analysis
   • balanced parentheses
2. Queue, circular queue and deque120 min
   • array modulo pointers
   • dynamic resizing queue
   • double-ended queue API
   • sliding window maximum queue
3. Monotonic stack and monotonic queue180 min
   • strictly increasing stack
   • decreasing stack invariant
   • window extrema maintenance
   • histogram rectangle area
4. Next greater element and stock span180 min
   • next greater element I and II
   • daily temperatures
   • stock span calculation
   • trapping rain water
5. Implementing a stack using queues and vice versa120 min
   • costly push stack
   • costly pop stack
   • single queue stack
   • two-stack queue
6. Expression evaluation and balanced parentheses120 min
   • infix to postfix conversion
   • evaluation of expression
   • min brackets to make valid
   • nested integer parser

Hands-on project: Build a postfix expression evaluator and calculator service handling operator precedence and parentheses.

You can implement hierarchical data structures, binary search trees, and prefix tries for rapid lookup.

1. Binary trees and traversals (in / pre / post / level order)180 min
   • recursive traversals
   • iterative traversals with stack
   • Morris traversal
   • level order BFS queue
2. Height, diameter, views and lowest common ancestor (LCA)240 min
   • maximum path sum
   • left and right tree views
   • binary tree vertical order
   • lowest common ancestor
3. Binary Search Trees: insert, delete and search180 min
   • BST property validation
   • insertion mechanics
   • deletion successor handling
   • sorted array to BST
4. Balanced trees: AVL and Red-Black overview180 min
   • tree rotations (LL, RR, LR, RL)
   • balance factor tracking
   • height invariant
   • Red-Black color properties
5. Tries (prefix trees)180 min
   • node character mapping
   • insert and search words
   • starts-with prefix check
   • word search II problem
6. Segment Trees and Fenwick Trees (BIT)180 min
   • range query operations
   • point updates
   • lazy propagation
   • binary indexed tree bit manipulation

Hands-on project: Build an auto-complete suggestion engine backed by a Trie and a frequency priority queue.

You can manage priority queues and hash tables to solve top-k and frequency aggregation problems.

1. Min-heaps, max-heaps and heapify120 min
   • complete binary tree array representation
   • percolate up and down
   • O(N) build heap
   • priority queue API
2. PriorityQueue in Java and Top-K problems180 min
   • k-th largest element in stream
   • top k frequent elements
   • merge k sorted lists
   • custom comparator heap
3. Finding the median in a data stream120 min
   • two-heap balancing
   • amortized insertion
   • odd/even stream size handling
   • sliding window median
4. Hash tables, hash functions and collisions120 min
   • chaining vs open addressing
   • hashCode and equals contract
   • load factor and rehashing
   • universal hashing concepts
5. HashMap and HashSet patterns180 min
   • two sum and variants
   • longest consecutive sequence
   • subarray sum equals k
   • group anagrams
6. Frequency counting and subarray-sum problems120 min
   • character frequency maps
   • majority element voting
   • contiguous array balancing
   • hash map optimizations

Hands-on project: Build a real-time streaming median income calculator using dual heaps (min-heap and max-heap).

You can model complex networks, compute shortest paths, and detect cycles using advanced graph algorithms.

1. Graph representations: adjacency list and matrix120 min
   • directed vs undirected
   • weighted vs unweighted
   • adjacency list memory efficiency
   • matrix space tradeoffs
2. Breadth-First Search (BFS) and Depth-First Search (DFS)180 min
   • queue-based BFS traversal
   • recursive DFS stack
   • connected components counting
   • bipartite graph check
3. Connected components and cycle detection180 min
   • directed graph cycle detection
   • undirected cycle via parent
   • bridge finding in graphs
   • articulation points
4. Topological sorting (Kahn's algorithm and DFS)180 min
   • dependency graph ordering
   • Kahn's in-degree queue
   • course schedule solver
   • alien dictionary problem
5. Shortest paths: Dijkstra, Bellman-Ford and Floyd-Warshall240 min
   • priority queue Dijkstra
   • negative weight edges
   • Bellman-Ford relaxation
   • all-pairs Floyd-Warshall
6. Minimum Spanning Tree: Kruskal and Prim180 min
   • greedy edge selection
   • Kruskal edge sorting
   • Prim priority queue approach
   • network design optimization
7. Union-Find (Disjoint Set Union)180 min
   • path compression heuristic
   • union by rank/size
   • connected components merging
   • redundant connection solver

Hands-on project: Build a city navigation route planner using Dijkstra's algorithm and adjacency lists loaded from GeoJSON data.

You can optimize overlapping subproblem recurrences using memoization, tabulation, and space compression.

1. DP fundamentals: memoization vs tabulation120 min
   • top-down recursion with cache
   • bottom-up iterative filling
   • overlapping subproblems
   • optimal substructure property
2. 1D DP: climbing stairs, house robber and Fibonacci180 min
   • state transition relations
   • space optimization variables
   • frog jump with energy
   • maximum alternating subsequence
3. Knapsack patterns: 0/1 and unbounded240 min
   • subset sum problem
   • coin change combinations
   • target sum partitioning
   • rod cutting problem
4. Subsequence DP: LIS, LCS and edit distance240 min
   • longest increasing subsequence
   • longest common subsequence
   • edit distance string matching
   • distinct subsequences
5. DP on grids and matrices180 min
   • unique paths with obstacles
   • minimum path sum grid
   • cherry pickup problem
   • maximal square in binary matrix
6. DP on trees and bitmask DP180 min
   • house robber III on trees
   • binary lifting LCA
   • travelling salesperson bitmask
   • maximum product subarray

Hands-on project: Build a financial portfolio optimization tool using 0/1 Knapsack and Matrix Chain Multiplication dynamic programming.

You can solve greedy scheduling, bitwise manipulation, and modular arithmetic algorithmic problems.

1. Greedy strategy and the exchange argument90 min
   • greedy choice property
   • proof by contradiction
   • activity selection
   • interval scheduling
2. Activity selection, interval scheduling and job sequencing120 min
   • minimum platforms required
   • merge overlapping intervals
   • job sequencing deadlines
   • lemonade change problem
3. Bit manipulation tricks and bitmasking120 min
   • bitwise AND/OR/XOR operations
   • single number detection
   • power of two check
   • subsets generation via bits
4. Number theory: GCD, Sieve of Eratosthenes and modular arithmetic90 min
   • Euclidean GCD algorithm
   • prime sieve optimization
   • modular inverse
   • fast exponentiation
5. Huffman coding and fractional knapsack90 min
   • prefix-free codes
   • greedy priority queue tree
   • value-to-weight ratio sorting
   • optimal storage allocation

Hands-on project: Implement an RSA encryption helper utility using modular exponentiation and prime number sieve generation.

You can test Java algorithms with JUnit, containerize applications with Docker, and monitor execution metrics.

1. Unit testing algorithms with JUnit 5120 min
   • assertions and parameterized tests
   • edge case test suites
   • performance benchmarking tests
   • code coverage reports with JaCoCo
2. Building and packaging with Maven and Gradle90 min
   • pom.xml dependency management
   • fat jar compilation
   • build lifecycle phases
   • dependency vulnerability scanning
3. Containerizing Java applications with Docker120 min
   • multi-stage Dockerfile builds
   • Eclipse Temurin JDK 21 runtime image
   • container resource limits
   • volume mounting for test inputs
4. Logging, error handling and observability90 min
   • SLF4J and Logback configuration
   • structured JSON logging
   • runtime memory profiling
   • uncaught exception handlers
5. CI/CD pipelines for automated verification90 min
   • GitHub Actions workflow setup
   • automated test execution on push
   • artifact publishing
   • linting and static code analysis

Hands-on project: Containerise a Java algorithmic execution engine with a multi-stage Dockerfile and add JUnit test suites for all data structures.

You can ace technical SDE interviews through live mock rounds, pattern matching, and profile optimization.

1. Company-wise problem patterns (FAANG, product and service firms)180 min
   • frequently asked interview problems
   • interviewer communication frameworks
   • clarifying constraints effectively
   • brute force to optimal transition
2. Live mock coding interviews with detailed feedback240 min
   • timed coding simulations
   • live peer code reviews
   • time-space complexity defense
   • personalized weak-spot coaching
3. System design basics for coding rounds120 min
   • scaling read-heavy systems
   • caching strategies with Redis
   • database sharding basics
   • load balancing fundamentals
4. Resume, LeetCode and GitHub profile building120 min
   • ATS-friendly resume structure
   • GitHub repository readmes
   • LeetCode contest rating strategy
   • portfolio presentation
5. HR and behavioural interview preparation90 min
   • STAR method for behavioral questions
   • negotiation strategies
   • handling difficult interview questions
   • cultural fit alignment

Hands-on project: Deliver a fully documented production-grade open-source algorithm library repository with CI/CD, tests, and a system design document.