Practice Data Structures & Algorithms in Java

How to learn Data Structures & Algorithms

Data-structure and algorithm practice is most useful when you learn reusable decision patterns rather than memorize finished answers. A pattern connects clues in the constraints to a small set of tools: sorted input may suggest two pointers, contiguous ranges suggest a window or prefix sum, and shortest unweighted paths suggest breadth-first search.

For every problem, first write the input size, desired result, and acceptable complexity. Then produce a simple correct approach before optimizing. That baseline exposes the repeated work an improved structure or invariant needs to remove.

Recommended learning order

1. Complexity and invariants: Count work and extra storage, and state what each loop variable or data structure means at any moment.
2. Linear sequence patterns: Learn two pointers, fixed and variable sliding windows, prefix sums, frequency maps, stacks, and queues on arrays and strings.
3. Recursive structures: Study recursion and backtracking, then trees and graphs with explicit visited-state and clear traversal order.
4. Optimization patterns: Move to heaps, binary search on answers, greedy reasoning, and dynamic programming after the simpler state representations are familiar.

Tested example: Find a pair in a sorted array

If the sum is too small, moving the left pointer is the only move that can increase it; if too large, moving the right pointer can decrease it. That invariant replaces a quadratic pair search with one pass.

import java.util.Arrays;

public class Main {
    static int[] pairWithSum(int[] sorted, int target) {
        int left = 0;
        int right = sorted.length - 1;
        while (left < right) {
            int sum = sorted[left] + sorted[right];
            if (sum == target) return new int[] {left, right};
            if (sum < target) left++;
            else right--;
        }
        return new int[] {-1, -1};
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(pairWithSum(new int[] {1, 3, 4, 7, 9}, 11)));
    }
}

Expected output

[2, 3]

Change and run this example in the Java compiler

Common mistakes

• Applying a remembered pattern without checking its precondition, such as using opposing pointers on unsorted data.
• Optimizing before a correct baseline exists, making both the logic and the performance claim hard to verify.
• Giving complexity only in terms of one variable when a graph or matrix has multiple relevant dimensions.
• Testing only the happy path and missing empty input, duplicate values, disconnected graphs, or arithmetic overflow.

How to practice

Work through the hub in pattern groups rather than random order. After solving, explain the invariant without code, record time and space complexity, and revisit the problem later from a blank editor. The recursion tutorial and DSA study guide provide the conceptual bridge to trees, graphs, and dynamic programming.

Exercises to do first

• Two sum in sorted data — Use the ordering invariant to discard one candidate after each comparison.
• Maximum fixed-window sum — Update a window by removing one value and adding one value.
• Longest substring with k distinct values — Maintain a frequency map while expanding and shrinking a valid window.