Java 算法题目练习实战指南

算法是程序员的核心竞争力，尤其在面试中。Java 作为主流语言，实现算法高效且优雅。本指南针对初学者到中级开发者，提供经典算法题目练习，结合 LeetCode 和《剑指 Offer》高频题。所有代码基于 Java 17+，已验证可运行。我们从基础概念开始，逐步深入实战。

1. 算法基础：时间与空间复杂度

理解 Big O 表示法是刷题前提。它描述算法随着输入规模增长的性能。

常见复杂度：O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ)

2. 常见数据结构可视化

掌握数据结构是算法基础。

• 数组：随机访问快 O(1)，插入删除慢 O(n)
• 链表：插入删除快 O(1)，访问慢 O(n)
• 栈/队列：LIFO/FIFO
• 树：二叉搜索树平均 O(log n)

3. 排序算法实战

排序是经典考点。这里实现三种常见算法，并可视化过程。

冒泡排序 (Bubble Sort)

public class BubbleSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        sort(arr);
        System.out.println(Arrays.toString(arr));  // [2, 3, 4, 5, 8]
    }
}

时间复杂度：O(n²)

快速排序 (Quick Sort)

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            sort(arr, low, pi - 1);
            sort(arr, pi + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        sort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));  // [2, 3, 4, 5, 8]
    }
}

平均时间复杂度：O(n log n)

4. LeetCode / 剑指 Offer 经典题目实战

选几道高频题，提供 Java 实现。

两数之和 (LeetCode 1)

import java.util.HashMap;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[]{map.get(complement), i};
            }
            map.put(nums[i], i);
        }
        return new int[]{};
    }
}

时间：O(n)，空间：O(n)

反转链表 (LeetCode 206 / 剑指 Offer 24)

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

迭代实现，O(n) 时间。

最大子数组和 (LeetCode 53 / 剑指 Offer 42)

class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        int sum = 0;
        for (int num : nums) {
            sum = Math.max(num, sum + num);
            max = Math.max(max, sum);
        }
        return max;
    }
}

Kadane 算法，O(n)。

二维数组中的查找 (剑指 Offer 04)

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
        int rows = matrix.length, cols = matrix[0].length;
        int row = 0, col = cols - 1;
        while (row < rows && col >= 0) {
            if (matrix[row][col] == target) return true;
            else if (matrix[row][col] > target) col--;
            else row++;
        }
        return false;
    }
}

从右上角开始，O(m + n)。

刷题建议与资源

• 顺序：先数组/字符串 → 链表 → 树 → 图 → 动态规划。
• 平台：LeetCode 中文站、牛客网剑指 Offer 专区。
• 推荐资源：
• 《代码随想录》GitHub：https://github.com/youngyangyang04/leetcode-master (支持 Java)
• JavaGuide 经典算法总结：https://javaguide.cn/cs-basics/algorithms/
• 每天 3-5 题，先想思路再看解法，多复盘。

坚持练习，算法能力会飞速提升！如果需要特定题目（如二叉树、DP）详细解析或更多代码，随时提问。加油！🚀