Trees in Java: Roots, Tree Types, DFS and BFS Traversals
Understand tree terminology and shapes, then learn inorder, preorder, postorder and level order with two larger examples, static dry runs and tested recursive and iterative Java.
Atlas / all routes
Each track connects code-level decisions to system-level consequences. Start with the foundations or jump to the map you need today.
Build pattern recognition through intuition, dry runs, complexity analysis, and Java-first solutions.
Build from modern Java and concurrency through Spring Boot applications and reliable microservices.
Turn requirements into clean objects, patterns, interfaces, and maintainable application code.
Reason about scale, failure, data, and trade-offs through architecture foundations and case studies.
Package, deploy, observe, and operate reliable systems using Docker and Kubernetes.
Build useful AI features through strong data, context, retrieval, evaluation, safety, and production engineering.
Standalone investigations into developer tooling, reliability, performance, experiments, and lessons from real engineering work.
Find a lesson across the Atlas. Drafts are not included.
Understand tree terminology and shapes, then learn inorder, preorder, postorder and level order with two larger examples, static dry runs and tested recursive and iterative Java.
Derive a calculator from grammar levels, with a quadratic baseline, linear recursive descent, commented Java, cursor-by-cursor dry run and integer division rules.
Understand exactly-k digit combinations with a subset baseline, take/skip recursion, safe sum bounds, commented Java and a complete illustrated dry run.
Build every matching arithmetic expression with operand boundaries, signed last-term tracking, leading-zero guards, commented Java and an illustrated dry run.
Learn phone-keypad backtracking from first principles, with examples, commented Java, a numbered image dry run, state restoration and output-sensitive complexity.
Derive the kth permutation from a backtracking baseline, factorial block sizes and zero-based ranks, with commented Java and an illustrated dry run.
Derive blindfolded DFS using relative coordinates, keep the robot's direction synchronized, and follow physical backtracking through commented Java and a static dry run.
Understand confusing numbers with digit rotation, valid-digit DFS, a complete recursion tree, commented Java, dry runs and justified complexity.
Solve graph coloring with tentative assignments, neighbor checks and backtracking; understand why a triangle needs three colors.
Generate all nonattacking queen boards with row-by-row backtracking, explain diagonal keys and undo, and trace the two solutions for n=4.
Enumerate palindrome partitions by choosing valid prefixes, copying completed paths and undoing; understand substring costs and minimum-cut differences.
Enumerate sorted maze paths with DFS, path-local visited cells and careful undo; handle blocked endpoints and preserve the input grid.
Solve Sudoku in place with first-empty-cell backtracking, explain row/column/box checks, and distinguish a safe trial from a complete solution.
Find a word through adjacent grid cells using path-local visited marks, short-circuit recursion and restoration, without reusing a cell.
Count upside-down-symmetric numbers in an inclusive string range with paired-digit recursion, safe comparisons, commented Java and a dry run.
Turn flat brace expressions into sorted choice groups, generate their Cartesian product with recursion, and distinguish nested Brace Expansion II.
Build reusable-candidate combinations with take/skip recursion, understand the remaining target and undo steps, and analyze output-sensitive complexity.
Understand i+1, sorted candidate pruning and sibling duplicate skipping with repeated values, a worked target-sum example and commented Java.
Build balanced parentheses using remaining counts, understand why close must exceed open, and trace the valid prefix tree.
Find the next time by bounded minute simulation, correctly handle midnight and unlimited digit reuse, and compare a recursive candidate generator.
Construct ranked tournament brackets round by round, understand Java reference passing, and count the real String-copying cost.
Generate sorted unique string permutations using your swap-and-backtrack approach, with per-position duplicate handling and an honest sorting cost.
Learn exponentiation by squaring, negative exponents, Integer.MIN_VALUE safety and the real call chain through commented Java.
Implement insertion sort with no loops, use separate recursive sorting and shifting helpers, and explain stability, the return phase and stack cost.
Reverse next and prev pointers in place, trace the saved original-next link, preserve node identity and choose safe iteration for long Java lists.
Generate upside-down-symmetric numbers by filling two ends together, handling leading zero and odd centers, with code and a visual dry run.
Understand take-or-skip recursion by producing every subset sum, with repeated sums, commented Java, a recursion tree and a dry run.
Generate unique subsets with duplicates using sorted sibling choices, preserve repeated values inside subsets, and understand copying and undo.
Find a complete knight tour with legal L moves, visited-state backtracking, success-preserving returns, a board example and tested Java.
Understand bijection, two string indices, candidate substrings, successful short-circuiting and undo with a beginner-friendly Word Pattern II solution.
Learn two pointers through palindrome checks, sorted pair sums, duplicate removal, merging, and fast/slow linked-list examples, with diagrams and explained Java code.
Learn parity-constrained permutations with simple reasoning, commented Java, a recursion tree and dry runs showing choices, returns and undo.
Learn why existence uses short-circuit returns, how take and skip reduce the remaining target, and how bounded subset-sum DP avoids repeated work.
Understand take-or-skip recursion, non-empty index choices, returned counts, and positive-target dynamic programming with commented Java and a real call tree.
Build only valid binary strings, understand every choose-and-undo step, and connect the recursion tree to Fibonacci counts and lexicographic order.
Understand odd frequencies, duplicate-free half permutations, shared state restoration, and a step-through recursion tree with fully commented Java.
Print backward without changing links or reading hidden fields, using recursive returns, an explicit-stack alternative and an API-faithful dry run.
Reverse a stack using recursion only, with insert-at-bottom reasoning, LIFO dry runs, commented Java and edge-case tests.
Reason about <=target and >target roots, preserve existing parent-child structure, trace pointer reconnections, and understand O(height) recursion with commented Java.
Generate sorted stepping numbers with digit-based DFS, boundary checks, safe arithmetic, an actual recursion tree, and beginner-friendly Java explanations.
Understand SOLID, DRY, KISS, YAGNI, coupling, cohesion, and composition through a Java login service with diagrams, failure cases, and runnable examples.
Learn BFS and DFS with static graph, queue and call-stack traces, tested Java, shortest paths, grids and 12 practical question patterns.
Count subarrays with sum K using a prefix sum and frequency map, with beginner-friendly diagrams, a dry run, Java solutions, and common mistakes.
Learn prefix sums from scratch with visual examples, Java code, recognition clues, common subarray patterns, and mistakes to avoid.
Learn Java encapsulation, abstraction, inheritance, polymorphism, access modifiers, class relationships, generics, and wildcards through the MealFlow design.
A practical AI engineering roadmap from Python and machine learning through LLMs, RAG, agents, MCP, production systems, and Forward Deployed Engineering.
A practical guide to escaping passive DSA study, recognizing algorithm patterns, debugging independently, and building a practice routine that lasts.
A structured system design interview roadmap covering requirements, scale, data, caching, distributed systems, reliability, security, and practice.
Learn Java OOP for low level design with classes, objects, constructors, references, shallow and deep copies, and the this keyword through clear examples.
A practical low level design roadmap covering OOP, UML, SOLID, design patterns, concurrency, interview planning, and the systems to practise next.
Generate every subset of a distinct integer set in Java using bitmasks and backtracking, with a visual dry run and honest complexity analysis.
Learn recursion in Java through base cases, smaller inputs, call-stack diagrams, Java code and complete static dry runs.
Reduce noisy pipeline logs into a small, safe, failure focused context before asking an LLM to explain what went wrong.
A practical mental model for building AI features that remain useful, measurable, safe, and affordable after the first demo.
Learn the requirements, numbers, data, and failure questions that should come before an architecture diagram.
Estimate traffic, storage, bandwidth, and concurrency with simple numbers that guide design choices.
Design a reliable URL shortening service from requirements through storage, caching, and failure handling.
A practical route through the Java concepts that matter when building backend services.
Compare the Java collections most backend applications use and choose by behavior instead of habit.
Follow an HTTP request from the controller through validation, business logic, persistence, and the response.
Understand images, containers, layers, processes, ports, and persistent data before writing Dockerfiles.
Build a smaller, safer Java container image with a multi stage Dockerfile and sensible runtime defaults.
Understand Pods, Deployments, Services, configuration, health checks, and resource settings as one workload.
Use prefix sums and earliest indexes to handle positive and negative values in linear time.
Find the missing value from 1 through n using XOR without overflow.
Merge two sorted arrays into a sorted list of distinct values with two pointers.
Move every zero to the end while preserving the order of nonzero values.
Rotate an array by k positions in place with the reversal technique.
Use read and write pointers to keep one copy of each value in place.
Verify nondecreasing order by checking each adjacent pair once.
Track the two largest distinct values in one pass without sorting the array.
Learn to keep a running maximum, reason about each comparison, and trace a one-pass Java solution.
Build a clear mental model for array indexing, traversal, updates, and common problem solving patterns.
Learn array traversal, two pointers, in place updates, hashing, and prefix techniques through Java examples.
A practical route through requirements, estimation, data, communication, reliability, and system design case studies.