Skip to content
AITroveRead. Build. Understand.
Reading list

DSA in Java

Java data-structure and algorithm programs preserve a representation invariant or a recurrence while making their input assumptions explicit.

Java data-structure and algorithm programs preserve a representation invariant or a recurrence while making their input assumptions explicit.

Count the whole operation

Binary search needs ordered input. Sorting an unsorted batch first is part of the cost. Recursion depth is not the same quantity as total work across all branches.

Common Mistakes

Test empty input, repeated values, boundary values, and an absent result. A correct output for one small fixture does not establish correctness for every valid input.

Working through this section

The curriculum below groups the canonical pages for this section. Open a lesson to see its release label, operation contract and connected topics. Examples can also be linked from another section without creating a second copy of the same page.

Compile the stated program with a compatible JDK and compare its result with the displayed output. Read the rejected-input and ownership clauses before changing the input. Local self-checks and downloaded programs do not imply a server-side code judge or a production service.

Curriculum

Define the input precondition and count total work.

  1. 1Linear search in Java
  2. 2Java binary search: lower bounds and duplicate values
  3. 3Java sorting: comparators, stability, and ownership

Prove progress, count all branches, and include stack space.

  1. 1Java recursion: base cases, stack depth, and bounded work

Track pending work and distinguish reachability from shortest distance.

  1. 1Java stack algorithm: validate nested delimiters
  2. 2Java binary-tree traversal: iterative inorder
  3. 3Java breadth-first search: shortest unweighted distances
  4. 4Java depth-first search: cycles and explicit work stacks

Prove progress and count work across all states.

  1. 1Java merge sort: stable merging and one scratch buffer
  2. 2Java memoization: minimum package count and cached subproblems

Prove pointer movement, preserve tree membership and bound retained candidates.

  1. 1Java two pointers: pair search on sorted input
  2. 2Java sliding windows: fixed-size range totals
  3. 3Java binary search trees: insertion, deletion and skew
  4. 4Java heaps: keep the largest k values with a small priority queue

Use the graph model and edge-cost preconditions that match the result.

  1. 1Java union-find: connected components and path compression
  2. 2Java Dijkstra: non-negative routes and stale heap entries
  3. 3Java topological sorting: prerequisites and cycle rejection

Restore temporary state and count result storage as well as search work.

  1. 1Java backtracking: subset choices and restoring state

Maintain height, prefix and heap invariants.

  1. 1Java AVL insertion: restoring a height invariant with rotations
  2. 2Java trie: prefix lookup with a declared alphabet
  3. 3Java binary min-heap: sifting, fixed capacity and duplicate priorities

Distinguish substring matches, forests and negative-edge distances.

  1. 1Java KMP substring search: reused prefix information and UTF-16 indices
  2. 2Java Kruskal: cheapest connecting forest and disjoint-set checks
  3. 3Java Bellman–Ford: negative edges and reachable negative cycles

Choose dependency order and state the exact objective.

  1. 1Java bottom-up tabulation: dependency order and unreachable states
  2. 2Java greedy interval selection: an exchange proof and a limited objective

Keep surviving structures valid after changes.

  1. 1Java AVL deletion: rebalance every surviving ancestor
  2. 2Java trie deletion: preserve shared prefixes and prune dead branches
  3. 3Java Fenwick tree: point additions and half-open prefix sums

Distinguish weighted distances from mutual reachability.

  1. 1Java Floyd–Warshall: all-pairs distances and negative-cycle rejection
  2. 2Java strongly connected components: mutual reachability with two traversals

State the text unit, order and capacity direction.

  1. 1Java edit distance: two rows and a declared text unit
  2. 2Java longest common subsequence: ordering without contiguity
  3. 3Java longest increasing subsequence: tails are search state
  4. 4Java 0/1 knapsack: reverse capacity iteration prevents reuse

Test exact boundaries, resource ownership and bounded work.

  1. 1Java segment tree: range sums with checked updates
  2. 2Java minimum coin change: reachable states and impossible totals

Inspect the state boundary and run its checked fixture.

  1. 1Java lazy segment tree: add to ranges and query sums

Follow the input contract, inspect failures and run the checked source.

  1. 1Java Z algorithm: find overlapping pattern matches in linear time
  2. 2Java graph bridges: track edge identity when parallel edges exist
  3. 3Java matrix-chain DP: minimize multiplication work without reordering matrices

Check the invariant, run the fixture and test a rejected boundary.

  1. 1Java prefix sums: answer repeated half-open range totals
  2. 2Java difference arrays: batch inclusive range additions
  3. 3Java next greater element: keep unresolved indices on a stack
  4. 4Java sliding-window maximum: evict expired indices and weaker tails
  5. 5Java weighted interval scheduling: end-time sort and predecessor DP
  6. 6Java bipartite matching: reroute an assignment with an augmenting path
  7. 7Java Edmonds-Karp max flow: residual capacity and reverse edges
  8. 8Java A* on a unit grid: an admissible Manhattan bound
Storage details