Java Data Structures

Java Data Structures and Algorithms (DSA) Tutorial

Learn Java Data Structures and Algorithms from beginner to interview-ready level with practical examples, clean Java code, complexity analysis, problem-solving patterns, and a structured DSA roadmap.

Introduction

Data Structures and Algorithms (DSA) are fundamental to writing efficient and scalable software. Data structures determine how information is organized, while algorithms define how that information is processed to solve a problem.

Learning DSA in Java is especially useful because Java provides a mature Collections Framework while still allowing you to implement core structures yourself. A strong DSA foundation helps with coding interviews, competitive programming, backend development, and performance-oriented software engineering.

By completing this tutorial, you will learn how to:

• Choose an appropriate data structure for a problem.
• Analyze time and space complexity using Big-O notation.
• Implement common data structures in Java.
• Understand searching, sorting, recursion, and graph traversal patterns.
• Recognize when hashing, heaps, trees, backtracking, greedy algorithms, or dynamic programming are appropriate.
• Build a systematic approach to coding interview problems.

This tutorial covers arrays, strings, linked lists, stacks, queues, trees, binary search trees, heaps, hashing, recursion, backtracking, dynamic programming, and an extended DSA roadmap.

What You Will Learn

1. Arrays
2. Strings
3. Linked Lists
4. Stacks
5. Queues
6. Trees
7. Graphs
8. Hashing
9. Heaps
10. Recursion
11. Backtracking
12. Dynamic Programming
13. Complexity analysis
14. Data structure selection
15. Practice problems
16. A Java DSA learning roadmap

What Is a Data Structure?

A data structure is a way of organizing data so that operations such as access, insertion, deletion, and searching can be performed efficiently.

Common examples include:

The best data structure depends on the operations your application performs most frequently.

Arrays

An array stores a fixed number of elements of the same type and provides direct index-based access.

Java arrays have a fixed length after creation.

Basic Java Example

javaCopy
1public class ArrayExample {
2    public static void main(String[] args) {
3        int[] numbers = {10, 20, 30, 40, 50};
4
5        int index = 2;
6
7        System.out.println("Element: " + numbers[index]);
8        System.out.println("Length: " + numbers.length);
9    }
10}

Output:

textCopy
1Element: 30
2Length: 5

Traversing an Array

javaCopy
1public class ArrayTraversal {
2    public static void main(String[] args) {
3        int[] numbers = {10, 20, 30, 40, 50};
4
5        for (int number : numbers) {
6            System.out.println(number);
7        }
8    }
9}

Finding the Maximum Element

javaCopy
1public class ArrayMaximum {
2    public static int findMaximum(int[] numbers) {
3        if (numbers == null || numbers.length == 0) {
4            throw new IllegalArgumentException("Array must not be empty");
5        }
6
7        int maximum = numbers[0];
8
9        for (int i = 1; i < numbers.length; i++) {
10            maximum = Math.max(maximum, numbers[i]);
11        }
12
13        return maximum;
14    }
15
16    public static void main(String[] args) {
17        int[] numbers = {7, 2, 19, 4, 11};
18
19        System.out.println(findMaximum(numbers));
20    }
21}

Output:

textCopy
119

Array Complexity

Arrays are a good choice when fast index-based access is more important than frequent resizing or middle insertion.

Strings

A Java String represents a sequence of characters. Strings are immutable, which means operations that appear to modify a string actually create a new string.

Basic String Example

javaCopy
1public class StringExample {
2    public static void main(String[] args) {
3        String language = "Java";
4
5        System.out.println(language.toUpperCase());
6        System.out.println(language.length());
7        System.out.println(language.contains("av"));
8    }
9}

Output:

textCopy
1JAVA
24
3true

Useful String Operations

Common methods include:

• length()
• charAt()
• substring()
• contains()
• startsWith()
• endsWith()
• replace()
• split()
• equals()
• indexOf()

Use StringBuilder for Repeated Modification

Repeated concatenation inside a loop can create many temporary String objects. StringBuilder is usually a better choice when building a string incrementally.

javaCopy
1public class StringBuilderExample {
2    public static void main(String[] args) {
3        StringBuilder builder = new StringBuilder();
4
5        for (int i = 1; i <= 5; i++) {
6            builder.append("Item ").append(i).append('\n');
7        }
8
9        System.out.print(builder);
10    }
11}

Palindrome Example

A palindrome reads the same from both directions.

javaCopy
1public class PalindromeChecker {
2    public static boolean isPalindrome(String value) {
3        if (value == null) {
4            return false;
5        }
6
7        int left = 0;
8        int right = value.length() - 1;
9
10        while (left < right) {
11            if (value.charAt(left) != value.charAt(right)) {
12                return false;
13            }
14
15            left++;
16            right--;
17        }
18
19        return true;
20    }
21
22    public static void main(String[] args) {
23        System.out.println(isPalindrome("level"));
24        System.out.println(isPalindrome("java"));
25    }
26}

Output:

textCopy
1true
2false

The two-pointer approach uses O(n) time and O(1) additional space.

Linked Lists

A linked list is made of nodes. Each node stores data and a reference to another node.

A singly linked list can be visualized as:

textCopy
110 -> 20 -> 30 -> 40 -> null

Unlike an array, linked-list nodes do not need to occupy contiguous memory locations.

Custom Singly Linked List

javaCopy
1public class SinglyLinkedList {
2
3    private static class Node {
4        int data;
5        Node next;
6
7        Node(int data) {
8            this.data = data;
9        }
10    }
11
12    private Node head;
13
14    public void addFirst(int data) {
15        Node newNode = new Node(data);
16        newNode.next = head;
17        head = newNode;
18    }
19
20    public void addLast(int data) {
21        Node newNode = new Node(data);
22
23        if (head == null) {
24            head = newNode;
25            return;
26        }
27
28        Node current = head;
29
30        while (current.next != null) {
31            current = current.next;
32        }
33
34        current.next = newNode;
35    }
36
37    public boolean contains(int target) {
38        Node current = head;
39
40        while (current != null) {
41            if (current.data == target) {
42                return true;
43            }
44
45            current = current.next;
46        }
47
48        return false;
49    }
50
51    public void print() {
52        Node current = head;
53
54        while (current != null) {
55            System.out.print(current.data + " -> ");
56            current = current.next;
57        }
58
59        System.out.println("null");
60    }
61
62    public static void main(String[] args) {
63        SinglyLinkedList list = new SinglyLinkedList();
64
65        list.addLast(10);
66        list.addLast(20);
67        list.addFirst(5);
68
69        list.print();
70        System.out.println(list.contains(20));
71    }
72}

Output:

textCopy
15 -> 10 -> 20 -> null
2true

Linked List Complexity

A linked list is useful when structural insertion and deletion are common and random access is not a primary requirement.

Stack

A stack follows the LIFO principle: Last In, First Out.

textCopy
1Push 10
2Push 20
3Push 30
4
5Top
630
720
810

Typical stack operations are:

• push() — add an element
• pop() — remove the top element
• peek() — inspect the top element
• isEmpty() — check whether the stack is empty

Preferred Java Stack Implementation

For modern Java applications, Deque is generally preferred over the legacy Stack class.

javaCopy
1import java.util.ArrayDeque;
2import java.util.Deque;
3
4public class StackExample {
5    public static void main(String[] args) {
6        Deque<Integer> stack = new ArrayDeque<>();
7
8        stack.push(10);
9        stack.push(20);
10        stack.push(30);
11
12        System.out.println("Top: " + stack.peek());
13        System.out.println("Removed: " + stack.pop());
14        System.out.println("Top: " + stack.peek());
15    }
16}

Output:

textCopy
1Top: 30
2Removed: 30
3Top: 20

Push, pop, and peek are O(1) amortized for this use.

Stack Applications

Stacks are commonly used for:

• Function-call management
• Undo operations
• Expression parsing
• Parentheses validation
• Depth-first search
• Backtracking

Queue

A queue follows the FIFO principle: First In, First Out.

textCopy
1Front
210 -> 20 -> 30 -> 40
3                     Rear

Common operations include:

• offer() — add an element
• poll() — remove the front element
• peek() — inspect the front element

Java Queue Example

javaCopy
1import java.util.ArrayDeque;
2import java.util.Queue;
3
4public class QueueExample {
5    public static void main(String[] args) {
6        Queue<Integer> queue = new ArrayDeque<>();
7
8        queue.offer(10);
9        queue.offer(20);
10        queue.offer(30);
11
12        System.out.println("Front: " + queue.peek());
13        System.out.println("Removed: " + queue.poll());
14        System.out.println("Front: " + queue.peek());
15    }
16}

Output:

textCopy
1Front: 10
2Removed: 10
3Front: 20

Queue Applications

Queues are useful for:

• Task scheduling
• Request processing
• Breadth-first search
• Message processing
• Producer-consumer systems

For a normal queue, offer, poll, and peek are O(1).

Trees

A tree is a hierarchical data structure composed of nodes connected by edges.

A binary tree can look like:

textCopy
1        10
2       /  \
3      5    20
4     / \
5    2   8

Important Tree Terminology

• Root — the top node.
• Parent — a node with one or more children.
• Child — a node connected below another node.
• Leaf — a node with no children.
• Depth — distance from the root.
• Height — longest downward path from a node to a leaf.

Binary Tree Traversals

The most common depth-first traversals are:

• Preorder: Root → Left → Right
• Inorder: Left → Root → Right
• Postorder: Left → Right → Root

Level-order traversal visits nodes level by level and is commonly implemented using a queue.

Binary Tree Node

javaCopy
1public class BinaryTreeTraversal {
2
3    static class Node {
4        int data;
5        Node left;
6        Node right;
7
8        Node(int data) {
9            this.data = data;
10        }
11    }
12
13    public static void inorder(Node node) {
14        if (node == null) {
15            return;
16        }
17
18        inorder(node.left);
19        System.out.print(node.data + " ");
20        inorder(node.right);
21    }
22
23    public static void main(String[] args) {
24        Node root = new Node(10);
25        root.left = new Node(5);
26        root.right = new Node(20);
27        root.left.left = new Node(2);
28        root.left.right = new Node(8);
29
30        inorder(root);
31    }
32}

Output:

textCopy
12 5 8 10 20

For a tree with n nodes, a complete traversal takes O(n) time.

Binary Search Tree

A Binary Search Tree (BST) maintains an ordering rule:

• Values smaller than a node are placed in its left subtree.
• Values greater than a node are placed in its right subtree.

BST Search Example

javaCopy
1public class BinarySearchTree {
2
3    static class Node {
4        int data;
5        Node left;
6        Node right;
7
8        Node(int data) {
9            this.data = data;
10        }
11    }
12
13    private Node root;
14
15    public void insert(int value) {
16        root = insertRecursive(root, value);
17    }
18
19    private Node insertRecursive(Node node, int value) {
20        if (node == null) {
21            return new Node(value);
22        }
23
24        if (value < node.data) {
25            node.left = insertRecursive(node.left, value);
26        } else if (value > node.data) {
27            node.right = insertRecursive(node.right, value);
28        }
29
30        return node;
31    }
32
33    public boolean contains(int value) {
34        Node current = root;
35
36        while (current != null) {
37            if (value == current.data) {
38                return true;
39            }
40
41            current = value < current.data
42                    ? current.left
43                    : current.right;
44        }
45
46        return false;
47    }
48
49    public static void main(String[] args) {
50        BinarySearchTree tree = new BinarySearchTree();
51
52        tree.insert(50);
53        tree.insert(30);
54        tree.insert(70);
55        tree.insert(20);
56        tree.insert(40);
57
58        System.out.println(tree.contains(40));
59    }
60}

A balanced BST can provide O(log n) search, insertion, and deletion. A badly skewed BST can degrade to O(n).

Graphs

A graph represents relationships between objects using vertices and edges.

textCopy
1A ----- B
2|       |
3|       |
4C ----- D

Graphs can be:

• Directed or undirected
• Weighted or unweighted
• Connected or disconnected
• Cyclic or acyclic

Graph Representation

An adjacency list is a common and memory-efficient representation for sparse graphs.

javaCopy
1import java.util.ArrayList;
2import java.util.List;
3
4public class GraphExample {
5    public static void main(String[] args) {
6        int vertices = 5;
7
8        List<List<Integer>> graph = new ArrayList<>();
9
10        for (int i = 0; i < vertices; i++) {
11            graph.add(new ArrayList<>());
12        }
13
14        graph.get(0).add(1);
15        graph.get(0).add(2);
16        graph.get(1).add(3);
17        graph.get(2).add(4);
18
19        System.out.println(graph);
20    }
21}

Breadth-First Search

BFS explores a graph level by level and uses a queue.

javaCopy
1import java.util.ArrayDeque;
2import java.util.ArrayList;
3import java.util.List;
4import java.util.Queue;
5
6public class BreadthFirstSearch {
7
8    public static void bfs(List<List<Integer>> graph, int start) {
9        boolean[] visited = new boolean[graph.size()];
10        Queue<Integer> queue = new ArrayDeque<>();
11
12        visited[start] = true;
13        queue.offer(start);
14
15        while (!queue.isEmpty()) {
16            int current = queue.poll();
17            System.out.print(current + " ");
18
19            for (int neighbor : graph.get(current)) {
20                if (!visited[neighbor]) {
21                    visited[neighbor] = true;
22                    queue.offer(neighbor);
23                }
24            }
25        }
26    }
27
28    public static void main(String[] args) {
29        List<List<Integer>> graph = new ArrayList<>();
30
31        for (int i = 0; i < 5; i++) {
32            graph.add(new ArrayList<>());
33        }
34
35        graph.get(0).add(1);
36        graph.get(0).add(2);
37        graph.get(1).add(3);
38        graph.get(2).add(4);
39
40        bfs(graph, 0);
41    }
42}

Output:

textCopy
10 1 2 3 4

BFS runs in O(V + E) time when the graph uses an adjacency-list representation.

Depth-First Search

DFS explores one path as deeply as possible before backtracking.

javaCopy
1import java.util.List;
2
3public class DepthFirstSearch {
4
5    public static void dfs(
6            List<List<Integer>> graph,
7            int current,
8            boolean[] visited
9    ) {
10        visited[current] = true;
11        System.out.print(current + " ");
12
13        for (int neighbor : graph.get(current)) {
14            if (!visited[neighbor]) {
15                dfs(graph, neighbor, visited);
16            }
17        }
18    }
19}

DFS is commonly used for connected components, cycle detection, topological reasoning, maze exploration, and many backtracking problems.

Hashing

Hashing maps keys to values using a hash function. In Java, the most commonly used hash-based collections are HashMap and HashSet.

HashMap Example

javaCopy
1import java.util.HashMap;
2import java.util.Map;
3
4public class HashMapExample {
5    public static void main(String[] args) {
6        Map<Integer, String> students = new HashMap<>();
7
8        students.put(1, "Ankit");
9        students.put(2, "Rahul");
10
11        System.out.println(students.get(1));
12        System.out.println(students.containsKey(2));
13    }
14}

Output:

textCopy
1Ankit
2true

Frequency Counting

Hashing is especially useful for counting frequencies.

javaCopy
1import java.util.HashMap;
2import java.util.Map;
3
4public class FrequencyCounter {
5    public static Map<Integer, Integer> countFrequencies(int[] numbers) {
6        Map<Integer, Integer> frequency = new HashMap<>();
7
8        for (int number : numbers) {
9            frequency.merge(number, 1, Integer::sum);
10        }
11
12        return frequency;
13    }
14
15    public static void main(String[] args) {
16        int[] numbers = {1, 2, 2, 3, 3, 3};
17
18        System.out.println(countFrequencies(numbers));
19    }
20}

Average-case insertion, lookup, and deletion are O(1), although hash-table operations can degrade in unfavorable cases.

Heap and Priority Queue

A heap is a complete binary tree that maintains a priority relationship.

Two common forms are:

• Min heap — smallest element has highest priority.
• Max heap — largest element has highest priority.

Java's PriorityQueue provides a min-heap by default.

Min Heap Example

javaCopy
1import java.util.PriorityQueue;
2import java.util.Queue;
3
4public class MinHeapExample {
5    public static void main(String[] args) {
6        Queue<Integer> minHeap = new PriorityQueue<>();
7
8        minHeap.offer(30);
9        minHeap.offer(10);
10        minHeap.offer(20);
11
12        while (!minHeap.isEmpty()) {
13            System.out.println(minHeap.poll());
14        }
15    }
16}

Output:

textCopy
110
220
330

Insertion and removal are O(log n), while inspecting the minimum element with peek() is O(1).

Max Heap in Java

javaCopy
1import java.util.Collections;
2import java.util.PriorityQueue;
3
4public class MaxHeapExample {
5    public static void main(String[] args) {
6        PriorityQueue<Integer> maxHeap =
7                new PriorityQueue<>(Collections.reverseOrder());
8
9        maxHeap.offer(10);
10        maxHeap.offer(30);
11        maxHeap.offer(20);
12
13        System.out.println(maxHeap.poll());
14    }
15}

Output:

textCopy
130

Heap Applications

Heaps are commonly used for:

• Priority scheduling
• Top-K problems
• Dijkstra's shortest-path algorithm
• Heap sort
• Event processing

Recursion

Recursion occurs when a method calls itself to solve smaller versions of the same problem.

A recursive solution normally contains:

1. A base case.
2. A recursive case that moves toward the base case.

Factorial Example

javaCopy
1public class FactorialExample {
2
3    public static long factorial(int n) {
4        if (n < 0) {
5            throw new IllegalArgumentException(
6                    "Factorial is undefined for negative numbers"
7            );
8        }
9
10        if (n == 0 || n == 1) {
11            return 1;
12        }
13
14        return n * factorial(n - 1);
15    }
16
17    public static void main(String[] args) {
18        System.out.println(factorial(5));
19    }
20}

Output:

textCopy
1120

The factorial algorithm takes O(n) time and O(n) call-stack space.

When to Use Recursion

Recursion is natural for:

• Tree traversal
• Divide-and-conquer algorithms
• Backtracking
• DFS
• Problems with recursive structure

For very deep recursion, an iterative solution may be safer because Java does not automatically optimize recursive calls into loops.

Backtracking

Backtracking systematically explores candidate solutions. When a partial solution cannot lead to a valid answer, the algorithm undoes the previous choice and tries another option.

The general pattern is:

textCopy
1Choose
2  |
3Explore
4  |
5Valid solution?
6  |       |
7 Yes      No
8  |        |
9Done     Undo choice
10           |
11        Try next

Backtracking is useful for:

• N-Queens
• Sudoku
• Maze solving
• Permutations
• Combinations
• Word search

Generic Backtracking Pattern

javaCopy
1public class BacktrackingPattern {
2
3    public static void search() {
4        if (isSolution()) {
5            recordSolution();
6            return;
7        }
8
9        for (int choice : getChoices()) {
10            if (!isValid(choice)) {
11                continue;
12            }
13
14            makeChoice(choice);
15            search();
16            undoChoice(choice);
17        }
18    }
19
20    private static boolean isSolution() {
21        return false;
22    }
23
24    private static void recordSolution() {
25        // Store or process the solution.
26    }
27
28    private static int[] getChoices() {
29        return new int[0];
30    }
31
32    private static boolean isValid(int choice) {
33        return true;
34    }
35
36    private static void makeChoice(int choice) {
37        // Update current state.
38    }
39
40    private static void undoChoice(int choice) {
41        // Restore previous state.
42    }
43}

The exact complexity of backtracking depends on the problem and branching factor, so it should not automatically be labeled with one fixed Big-O value.

Dynamic Programming

Dynamic Programming (DP) is useful when a problem contains overlapping subproblems and the solution can be built from optimal solutions to smaller subproblems.

Two common approaches are:

• Memoization — top-down recursion with cached results.
• Tabulation — bottom-up iteration using a table.

Fibonacci Without Dynamic Programming

The naive recursive Fibonacci implementation repeats the same calculations many times.

javaCopy
1public static int fibonacci(int n) {
2    if (n <= 1) {
3        return n;
4    }
5
6    return fibonacci(n - 1) + fibonacci(n - 2);
7}

Its time complexity is exponential, commonly described as O(2^n).

Fibonacci with Memoization

javaCopy
1import java.util.Arrays;
2
3public class FibonacciMemoization {
4
5    public static long fibonacci(int n, long[] memo) {
6        if (n <= 1) {
7            return n;
8        }
9
10        if (memo[n] != -1) {
11            return memo[n];
12        }
13
14        memo[n] = fibonacci(n - 1, memo)
15                + fibonacci(n - 2, memo);
16
17        return memo[n];
18    }
19
20    public static void main(String[] args) {
21        int n = 50;
22        long[] memo = new long[n + 1];
23
24        Arrays.fill(memo, -1);
25
26        System.out.println(fibonacci(n, memo));
27    }
28}

The memoized solution reduces the time complexity to O(n), with O(n) additional memory.

Fibonacci with Tabulation

javaCopy
1public class FibonacciTabulation {
2
3    public static long fibonacci(int n) {
4        if (n <= 1) {
5            return n;
6        }
7
8        long[] dp = new long[n + 1];
9
10        dp[0] = 0;
11        dp[1] = 1;
12
13        for (int i = 2; i <= n; i++) {
14            dp[i] = dp[i - 1] + dp[i - 2];
15        }
16
17        return dp[n];
18    }
19
20    public static void main(String[] args) {
21        System.out.println(fibonacci(50));
22    }
23}

This solution runs in O(n) time and O(n) space. The space can be optimized to O(1) because only the previous two values are required.

Big-O Time and Space Complexity

Big-O notation describes how resource usage grows as the input size increases.

Common complexities include:

Example: Linear Search

javaCopy
1public static int linearSearch(int[] numbers, int target) {
2    for (int i = 0; i < numbers.length; i++) {
3        if (numbers[i] == target) {
4            return i;
5        }
6    }
7
8    return -1;
9}

The worst-case time complexity is O(n).

Example: Binary Search

Binary search works on a sorted array and repeatedly halves the search interval.

javaCopy
1public static int binarySearch(int[] numbers, int target) {
2    int left = 0;
3    int right = numbers.length - 1;
4
5    while (left <= right) {
6        int middle = left + (right - left) / 2;
7
8        if (numbers[middle] == target) {
9            return middle;
10        }
11
12        if (numbers[middle] < target) {
13            left = middle + 1;
14        } else {
15            right = middle - 1;
16        }
17    }
18
19    return -1;
20}

Binary search runs in O(log n) time and O(1) auxiliary space in this iterative implementation.

Common Data Structure Complexity

* Insertion at the beginning or after a known node.

** Deletion can be O(1) when the required node/reference and necessary predecessor information are already available; locating the node can still require O(n).

Actual performance can vary depending on the implementation and operation being measured.

When to Use Which Data Structure

Do not choose a data structure only because it is theoretically fast. Consider memory usage, ordering requirements, access patterns, implementation complexity, and the operations your application performs most often.

Java Collections You Should Know

For practical Java development and coding interviews, become comfortable with:

javaCopy
1List<Integer> list = new ArrayList<>();
2Set<Integer> set = new HashSet<>();
3Map<String, Integer> map = new HashMap<>();
4Deque<Integer> stack = new ArrayDeque<>();
5Queue<Integer> queue = new ArrayDeque<>();
6PriorityQueue<Integer> heap = new PriorityQueue<>();

Prefer programming against interfaces such as List, Set, Map, Queue, and Deque rather than coupling code unnecessarily to a concrete implementation.

Best Practices for Java DSA

• Understand the problem before selecting a data structure.
• Estimate time and space complexity before coding.
• Use descriptive variable and method names.
• Validate important inputs and define edge-case behavior.
• Prefer ArrayDeque for stack and queue use cases.
• Use StringBuilder when repeatedly constructing strings.
• Avoid unnecessary object creation inside performance-sensitive loops.
• Use recursion when it makes the solution clearer and the recursion depth is safe.
• Practice implementing core structures manually so you understand how they work internally.
• Test empty input, one-element input, duplicate values, negative values, and large input where applicable.
• Optimize only after establishing a correct baseline solution.

How to Solve DSA Problems

A repeatable problem-solving process is more valuable than memorizing solutions.

Step 1: Understand the Problem

Identify:

• Input format
• Expected output
• Constraints
• Duplicate or negative values
• Whether the input is sorted
• Whether order matters

Step 2: Start with a Brute-Force Solution

First create a correct solution, even if it is not optimal. This gives you a baseline for improving the algorithm.

Step 3: Identify the Pattern

Ask whether the problem resembles:

• Two pointers
• Sliding window
• Binary search
• Hashing
• Stack
• Queue
• BFS
• DFS
• Backtracking
• Greedy
• Dynamic programming

Step 4: Analyze Complexity

Calculate:

• Time complexity
• Auxiliary space complexity

Then determine whether the solution satisfies the input constraints.

Step 5: Test Edge Cases

Consider:

textCopy
1Empty input
2Single element
3All elements equal
4Already sorted input
5Reverse-sorted input
6Very large values
7Duplicate values
8No valid answer
9Multiple valid answers

Practice Problems

Arrays

• Find the maximum element.
• Find the second-largest element.
• Reverse an array.
• Rotate an array.
• Solve Two Sum.
• Merge two sorted arrays.
• Find the missing number.
• Find duplicate values.

Strings

• Reverse a string.
• Check whether a string is a palindrome.
• Count character frequencies.
• Check whether two strings are anagrams.
• Find the longest common prefix.
• Find the first non-repeating character.

Linked Lists

• Reverse a linked list.
• Find the middle node.
• Detect a cycle.
• Merge two sorted linked lists.
• Remove the Nth node from the end.

Stack and Queue

• Valid Parentheses.
• Min Stack.
• Implement a queue using stacks.
• Implement a stack using queues.
• Evaluate a postfix expression.
• Find the next greater element.

Trees

• Implement preorder, inorder, and postorder traversal.
• Find maximum tree depth.
• Check whether two trees are identical.
• Validate a BST.
• Find the lowest common ancestor.
• Perform level-order traversal.

Graphs

• Implement BFS.
• Implement DFS.
• Count connected components.
• Detect a cycle.
• Find a shortest path in an unweighted graph.
• Solve a grid traversal problem.

Dynamic Programming

• Fibonacci.
• Climbing Stairs.
• House Robber.
• Coin Change.
• Longest Common Subsequence.
• 0/1 Knapsack.
• Longest Increasing Subsequence.

Final DSA Roadmap

A practical order for learning Java DSA is:

1. Java fundamentals
2. Arrays
3. Strings
4. ArrayList and Java Collections
5. Linked Lists
6. Stack and Queue
7. HashMap and HashSet
8. Sorting
9. Binary Search
10. Trees
11. Binary Search Trees
12. Heap and PriorityQueue
13. Recursion
14. Backtracking
15. Greedy Algorithms
16. Graphs
17. Dynamic Programming
18. Advanced graph algorithms
19. Tries
20. Segment Trees and other advanced structures

Summary

Data Structures and Algorithms provide the foundation for efficient problem solving. In Java, understanding both the underlying concepts and the standard Collections Framework is important.

You should now understand:

• How arrays and strings store and process data.
• How linked lists connect nodes.
• How stacks and queues model LIFO and FIFO behavior.
• How trees represent hierarchical information.
• How graphs represent relationships.
• How hash tables provide fast average-case lookup.
• How heaps support priority-based operations.
• How recursion and backtracking explore problem spaces.
• How dynamic programming avoids repeated computation.
• How Big-O notation helps compare algorithms.
• How to choose a data structure based on problem requirements.

The next step is practice. Implement each structure yourself, solve progressively harder problems, and always explain the time and space complexity of your solution.