Java算法入门从刷LeetCode第一题开始手把手教你用Java实现排序查找数据结构从面试真题到实战项目全解析

朋友，如果你现在正坐在电脑前，准备开始学习Java算法，或者已经在LeetCode上被第一题卡住了——先恭喜你，你走对路了。算法这件事，看着吓人，其实只要你肯一步一步来，真的没啥可怕的。今天我就带你从零开始，把排序、查找、数据结构这些核心内容全部掰开了、揉碎了讲给你听。咱们不玩虚的，直接上干货，代码能跑的，例子能看懂的，面试能用的。

先说个题外话。我第一次接触算法的时候，是在大三准备秋招。那时候看到”两数之和”这道题，题目明明很短，我愣是看了半天没搞明白为啥有人要用哈希表来解。后来我花了一个月时间，把LeetCode上热题100全部过了一遍，才真正体会到算法的魅力。所以今天我想把这些年的经验，用最平实的方式讲给你听。

---

从”两数之和”开始，建立你的算法思维

LeetCode第一题是”两数之和”，题目很简单：给你一个整数数组nums和一个目标值target，请你找出数组中和为目标值的两个整数，并返回它们的数组下标。

很多初学者上来就用暴力解法，两层循环，时间复杂度是O(n²)。代码大概长这样：

public int[] twoSum(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

这段代码能跑，也能通过，但面试官一定会追问：有没有更优的解法？这时候你就需要展现出你的思考能力了。

关键在于，我们不需要每次都去遍历剩下的元素来找”目标值减去当前值”的结果。我们可以用一个哈希表，在遍历数组的同时，把已经遍历过的元素存进去。这样每次只需要O(1)的时间就能判断目标值是否已经存在。

import java.util.HashMap;
import java.util.Map;

public int[] twoSum(int[] nums, int target) {
    Map<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);
    }
    throw new IllegalArgumentException("No two sum solution");
}

这段代码的时间复杂度是O(n)，空间复杂度也是O(n)。对比一下，暴力解法是O(n²)时间，O(1)空间。面试的时候，你能说出这种trade-off（权衡），面试官就会觉得你确实有思考。

我建议你刚开始刷LeetCode的时候，不要只满足于”做出来”。每道做完的题，都问问自己：有没有更优解法？时间复杂度和空间复杂度分别是什么？边界情况有哪些？这种思考习惯，会帮你在大厂面试中脱颖而出。

---

排序算法：从冒泡到快速排序的进阶之路

排序是算法的基石，几乎所有高级算法都会用到排序。咱们从一个最简单的说起。

冒泡排序：理解排序的第一步

冒泡排序的原理是：重复遍历数组，每次比较相邻的两个元素，如果顺序错了就交换。这样每一轮都能把一个最大的元素”冒泡”到末尾。

public void bubbleSort(int[] nums) {
    int n = nums.length;
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (nums[j] > nums[j + 1]) {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
                swapped = true;
            }
        }
        // 如果没有发生交换，说明已经有序，提前结束
        if (!swapped) {
            break;
        }
    }
}

这段代码的时间复杂度是O(n²)，空间复杂度是O(1)。看起来很慢，但它的价值在于帮助你理解排序的基本思想。我在教大学弟弟的时候，总是先从冒泡排序开始讲，因为它的逻辑最直观，孩子能看懂”为什么这个数会跑到最后面去”。

快速排序：面试必考的高频算法

快速排序是实际开发中最常用的排序算法之一，也是面试中最常被问到的。它的核心思想是”分治”：选一个基准元素，把比它小的放左边，比它大的放右边，然后对左右两部分递归排序。

public void quickSort(int[] nums, int left, int right) {
    if (left < right) {
        int pivotIndex = partition(nums, left, right);
        quickSort(nums, left, pivotIndex - 1);
        quickSort(nums, pivotIndex + 1, right);
    }
}

private int partition(int[] nums, int left, int right) {
    int pivot = nums[right]; // 选最后一个元素作为基准
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (nums[j] <= pivot) {
            i++;
            swap(nums, i, j);
        }
    }
    swap(nums, i + 1, right);
    return i + 1;
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

快速排序的平均时间复杂度是O(n log n)，最坏情况是O(n²)（当数组已经有序时）。实际应用中，我们可以通过随机选择基准元素或者三数取中法来避免最坏情况。

很多面试会问你：快速排序和归并排序有什么区别？快速排序是原地排序，空间复杂度是O(log n)，而归并排序需要额外的O(n)空间。快速排序的平均性能更好，但归并排序在最坏情况下也能保证O(n log n)。这些都是面试中的高频追问点。

归并排序：稳定排序的典范

归并排序的核心思想也是分治，但它先把数组分成两半分别排序，然后再合并。合并的过程是面试中经常被要求手写的关键部分。

public void mergeSort(int[] nums, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        merge(nums, left, mid, right);
    }
}

private void merge(int[] nums, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j]) {
            temp[k++] = nums[i++];
        } else {
            temp[k++] = nums[j++];
        }
    }
    
    while (i <= mid) {
        temp[k++] = nums[i++];
    }
    while (j <= right) {
        temp[k++] = nums[j++];
    }
    
    for (int p = 0; p < temp.length; p++) {
        nums[left + p] = temp[p];
    }
}

归并排序的时间复杂度是O(n log n)，而且是稳定排序（相等元素的相对顺序不会改变）。这在处理需要保持稳定性的场景时非常重要，比如对订单列表按金额排序后，相同金额的订单要保持原有的时间顺序。

---

查找算法：二分查找及其变种

如果说排序是算法的基石，那二分查找就是算法技巧的代表。它的原理很简单：在一个有序数组中，每次取中间元素和目标值比较，如果中间元素比目标值大，就在左半边继续查找；如果小，就在右半边查找。

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1; // 没找到
}

这段代码看起来简单，但细节很重要。mid的计算不能写成(left + right) / 2，因为left + right可能会溢出。写成left + (right - left) / 2更安全。

二分查找的变种很多，面试中经常考的是”搜索插入位置”、”第一个错误版本”、”旋转数组搜索”等题目。我给你讲一个最常见的变种：找到第一个大于等于目标值的位置。

public int findFirstGreaterOrEqual(int[] nums, int target) {
    int left = 0, right = nums.length;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

这道题的关键在于边界条件的处理。right初始化为nums.length而不是nums.length - 1，是因为目标值可能比所有元素都大，这时候应该返回数组长度。这种边界处理的能力，是区分初级和中级工程师的重要标志。

---

数据结构：哈希表、链表、栈和队列

算法和数据结构是分不开的。我给你重点讲几个面试中最常出现的数据结构。

哈希表：O(1)查询的神器

哈希表是实际开发中最常用的数据结构之一。它的核心思想是通过哈希函数把键映射到数组的下标，从而实现O(1)的查找、插入和删除。

在Java中，我们通常使用HashMap或Hashtable。但面试中经常让你手写一个简化版的哈希表，考察你对哈希冲突的理解。

public class MyHashMap {
    private static final int DEFAULT_CAPACITY = 1000;
    private LinkedList<Integer>[] buckets;
    
    public MyHashMap() {
        buckets = new LinkedList[DEFAULT_CAPACITY];
        for (int i = 0; i < DEFAULT_CAPACITY; i++) {
            buckets[i] = new LinkedList<>();
        }
    }
    
    private int hash(int key) {
        return Math.abs(key) % DEFAULT_CAPACITY;
    }
    
    public void put(int key) {
        int index = hash(key);
        if (!buckets[index].contains(key)) {
            buckets[index].add(key);
        }
    }
    
    public void remove(int key) {
        int index = hash(key);
        buckets[index].remove(Integer.valueOf(key));
    }
    
    public boolean contains(int key) {
        int index = hash(key);
        return buckets[index].contains(key);
    }
}

这段代码展示了哈希表的基本原理：通过哈希函数映射到不同的桶（bucket），每个桶内部用链表处理哈希冲突。实际生产环境中的HashMap会在这基础上做很多优化，比如树化（当链表长度超过8时转为红黑树），但你理解了这些基础原理，面试手撕代码就不会慌。

链表：反转、合并、检测环

链表是面试中的常客，尤其是反转链表这道题。我给你讲三种不同的反转方式。

// 方法一：迭代法
public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}

// 方法二：递归法
public ListNode reverseListRecursive(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode newHead = reverseListRecursive(head.next);
    head.next.next = head;
    head.next = null;
    return newHead;
}

// 方法三：头插法
public ListNode reverseListHeadInsert(ListNode head) {
    ListNode dummy = new ListNode(0);
    ListNode curr = head;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = dummy.next;
        dummy.next = curr;
        curr = nextTemp;
    }
    return dummy.next;
}

这三种方法中，迭代法最直观，递归法最简洁，头插法最巧妙。面试时能说出三种解法，并且分析它们的时间和空间复杂度，你就已经超越了80%的候选人。

链表的其他高频题目包括：检测环（用快慢指针）、找环的入口、合并两个有序链表、回文链表判断等。我给你讲一个快慢指针的经典应用：判断链表是否有环。

public boolean hasCycle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) {
            return true;
        }
    }
    return false;
}

这个算法的精妙之处在于：如果链表有环，快指针一定会追上慢指针，就像在跑道上跑步一样。这个思想可以扩展到很多其他问题，比如找链表的中间节点、倒数第k个节点等。

栈和队列：括号匹配、单调栈、滑动窗口

栈是”后进先出”的数据结构，队列是”先进先出”的数据结构。它们在很多算法问题中都有重要应用。

栈的经典应用是括号匹配问题：

public boolean isValid(String s) {
    if (s.length() % 2 != 0) {
        return false;
    }
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(') {
            stack.push(')');
        } else if (c == '{') {
            stack.push('}');
        } else if (c == '[') {
            stack.push(']');
        } else {
            if (stack.isEmpty() || stack.pop() != c) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

这道题的关键在于：把左括号对应的右括号压入栈，这样遇到右括号时只需要和栈顶比较即可。单调栈是栈的进阶应用，用于解决”下一个更大元素”等问题。我给你讲一个经典的例子：给定一个数组，找出每个元素右边第一个比它大的元素。

public int[] nextGreaterElement(int[] nums) {
    int n = nums.length;
    int[] result = new int[n];
    Arrays.fill(result, -1);
    Deque<Integer> stack = new ArrayDeque<>(); // 存下标
    
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
            int index = stack.pop();
            result[index] = nums[i];
        }
        stack.push(i);
    }
    
    return result;
}

队列的经典应用是滑动窗口问题。我给你讲一个最常见的例子：找出滑动窗口的最大值。

public int[] maxSlidingWindow(int[] nums, int k) {
    if (nums.length == 0 || k == 0) {
        return new int[0];
    }
    
    int[] result = new int[nums.length - k + 1];
    Deque<Integer> deque = new ArrayDeque<>(); // 双端队列，存下标
    
    for (int i = 0; i < nums.length; i++) {
        // 移除不在窗口内的元素
        if (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
            deque.pollFirst();
        }
        // 移除比当前元素小的元素（它们不可能成为最大值）
        while (!deque.isEmpty() && nums[i] >= nums[deque.peekLast()]) {
            deque.pollLast();
        }
        deque.offerLast(i);
        
        // 记录结果
        if (i >= k - 1) {
            result[i - k + 1] = nums[deque.peekFirst()];
        }
    }
    
    return result;
}

这道题用双端队列实现了O(n)的时间复杂度，比用优先队列的O(n log k)更优。面试中如果能说出这种优化思路，会给面试官留下很好的印象。

---

二叉树：递归与迭代的完美结合

二叉树是面试中的重中之重，很多问题都可以用递归或迭代的方式解决。我给你讲几个最经典的题目。

二叉树的前中后序遍历

前序遍历：根节点 -> 左子树 -> 右子树 中序遍历：左子树 -> 根节点 -> 右子树 后序遍历：左子树 -> 右子树 -> 根节点

// 递归实现
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    preorderHelper(root, result);
    return result;
}

private void preorderHelper(TreeNode node, List<Integer> result) {
    if (node == null) {
        return;
    }
    result.add(node.val);
    preorderHelper(node.left, result);
    preorderHelper(node.right, result);
}

// 迭代实现（前序）
public List<Integer> preorderTraversalIterative(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    if (root == null) {
        return result;
    }
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        result.add(node.val);
        // 注意：先压右子树，再压左子树，这样左子树先出栈
        if (node.right != null) {
            stack.push(node.right);
        }
        if (node.left != null) {
            stack.push(node.left);
        }
    }
    return result;
}

前序遍历的迭代实现是面试中的常考题，关键是要理解栈的”后进先出”特性。中序和后序的迭代实现类似，但稍微复杂一些。我建议你亲手把这三种遍历的递归和迭代实现都写一遍，这样才能真正理解。

二叉树的最大深度

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

这道题看似简单，但它展示了递归的精髓：把大问题分解为小问题。求一棵树的最大深度，等于求左右子树最大深度的较大值加1。这种思想在很多树的问题中都有应用。

二叉树的层序遍历

层序遍历需要用到队列：

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> result = new ArrayList<>();
    if (root == null) {
        return result;
    }
    
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while (!queue.isEmpty()) {
        int levelSize = queue.size();
        List<Integer> currentLevel = new ArrayList<>();
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode node = queue.poll();
            currentLevel.add(node.val);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        
        result.add(currentLevel);
    }
    
    return result;
}

层序遍历的关键是：每层遍历完后再处理下一层。通过记录每层的节点数量，可以实现这个功能。这道题是面试中的高频题，很多变种题目（如二叉树的锯齿形层序遍历、二叉树的右视图等）都可以基于此扩展。

---

动态规划：从斐波那契到背包问题

动态规划是算法中最难也是最有价值的部分。它的基本思想是：把大问题分解为小问题，保存小问题的解，避免重复计算。

斐波那契数列：动态规划的入门题

// 方法一：递归（有重复计算）
public int fibRecursive(int n) {
    if (n <= 1) {
        return n;
    }
    return fibRecursive(n - 1) + fibRecursive(n - 2);
}

// 方法二：记忆化搜索
public int fibMemo(int n) {
    int[] memo = new int[n + 1];
    Arrays.fill(memo, -1);
    return fibMemoHelper(n, memo);
}

private int fibMemoHelper(int n, int[] memo) {
    if (n <= 1) {
        return n;
    }
    if (memo[n] != -1) {
        return memo[n];
    }
    memo[n] = fibMemoHelper(n - 1, memo) + fibMemoHelper(n - 2, memo);
    return memo[n];
}

// 方法三：动态规划（自底向上）
public int fibDP(int n) {
    if (n <= 1) {
        return n;
    }
    int[] dp = new int[n + 1];
    dp[0] = 0;
    dp[1] = 1;
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

// 方法四：空间优化
public int fibOptimized(int n) {
    if (n <= 1) {
        return n;
    }
    int prev2 = 0;
    int prev1 = 1;
    int current = 0;
    for (int i = 2; i <= n; i++) {
        current = prev1 + prev2;
        prev2 = prev1;
        prev1 = current;
    }
    return current;
}

这道题展示了动态规划的完整演进过程：从暴力递归到记忆化搜索，再到动态规划，最后到空间优化。面试中，你至少需要掌握前三种方法，并能够解释它们的时间复杂度和空间复杂度。

0-1背包问题：动态规划的经典应用

背包问题是动态规划的入门必做题：

public int knapsack(int[] weights, int[] values, int capacity) {
    int n = weights.length;
    int[][] dp = new int[n + 1][capacity + 1];
    
    for (int i = 1; i <= n; i++) {
        for (int w = 0; w <= capacity; w++) {
            if (weights[i - 1] <= w) {
                dp[i][w] = Math.max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1]);
            } else {
                dp[i][w] = dp[i - 1][w];
            }
        }
    }
    
    return dp[n][capacity];
}

// 空间优化版本
public int knapsackOptimized(int[] weights, int[] values, int capacity) {
    int[] dp = new int[capacity + 1];
    
    for (int i = 0; i < weights.length; i++) {
        for (int w = capacity; w >= weights[i]; w--) {
            dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]);
        }
    }
    
    return dp[capacity];
}

背包问题的核心在于状态转移方程：dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i]] + values[i])。这个方程的意思是：对于第i个物品，我们可以选择放或不放。如果放，就加上它的价值；如果不放，就保持原来的最大价值。

---

面试真题：大厂高频题目解析

我给你整理了一些大厂面试中的高频题目，并给出解题思路。

真题1：合并K个升序链表

这道题是LeetCode硬题100中的经典题，出现在很多大厂的面试中。

import java.util.PriorityQueue;

public ListNode mergeKLists(ListNode[] lists) {
    if (lists == null || lists.length == 0) {
        return null;
    }
    
    // 最小堆，按节点值排序
    PriorityQueue<ListNode> heap = new PriorityQueue<>((a, b) -> a.val - b.val);
    
    // 把所有链表的头节点加入堆
    for (ListNode node : lists) {
        if (node != null) {
            heap.offer(node);
        }
    }
    
    ListNode dummy = new ListNode(0);
    ListNode curr = dummy;
    
    while (!heap.isEmpty()) {
        ListNode minNode = heap.poll();
        curr.next = minNode;
        curr = curr.next;
        
        if (minNode.next != null) {
            heap.offer(minNode.next);
        }
    }
    
    return dummy.next;
}

这道题的关键在于使用最小堆来维护K个链表的当前最小节点。时间复杂度是O(N log K)，其中N是所有节点的总数，K是链表的个数。

真题2：最长无重复字符的子串

public int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> map = new HashMap<>();
    int maxLen = 0;
    int left = 0;
    
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (map.containsKey(c) && map.get(c) >= left) {
            left = map.get(c) + 1;
        }
        map.put(c, right);
        maxLen = Math.max(maxLen, right - left + 1);
    }
    
    return maxLen;
}

这道题用滑动窗口解决，关键是要理解当遇到重复字符时，左边界应该跳到重复字符上次出现位置的下一个位置。

真题3：LRU缓存

import java.util.HashMap;
import java.util.Map;

class LRUCache {
    private int capacity;
    private Map<Integer, Integer> cache;
    private Node head;
    private Node tail;
    
    private class Node {
        int key;
        int value;
        Node prev;
        Node next;
        
        Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        cache = new HashMap<>();
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        if (!cache.containsKey(key)) {
            return -1;
        }
        Node node = cache.get(key);
        moveToHead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            node.value = value;
            moveToHead(node);
        } else {
            if (cache.size() >= capacity) {
                Node tailNode = removeTail();
                cache.remove(tailNode.key);
            }
            Node newNode = new Node(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
        }
    }
    
    private void addToHead(Node node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }
    
    private void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    
    private void moveToHead(Node node) {
        removeNode(node);
        addToHead(node);
    }
    
    private Node removeTail() {
        Node node = tail.prev;
        removeNode(node);
        return node;
    }
}

LRU缓存是面试中的高频题，考察的是对哈希表和双向链表的综合运用。关键在于理解”最近使用”的概念：每次访问一个节点后，需要把它移到链表的头部。

---

实战项目：把算法应用到真实场景

算法不是空中楼阁，它需要应用到实际项目中才有价值。我给你讲两个实际的例子。

例子1：实现一个简单的缓存系统

前面讲的LRU缓存，可以直接应用到实际的缓存系统中。比如在Spring Boot项目中，你可以基于这个实现做一个简单的本地缓存：

import org.springframework.stereotype.Component;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@Component
public class SimpleCache<K, V> {
    private final int capacity;
    private final LRUCache<K, V> lruCache;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public SimpleCache(int capacity) {
        this.capacity = capacity;
        this.lruCache = new LRUCache<>(capacity);
    }
    
    public V get(K key) {
        lock.readLock().lock();
        try {
            return lruCache.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public void put(K key, V value) {
        lock.writeLock().lock();
        try {
            lruCache.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

这个简单的缓存系统可以用于缓存一些频繁查询但不常变化的数据，比如配置信息、热点数据等。

例子2：实现一个简单的搜索引擎

搜索是最能体现算法价值的场景之一。我给你讲如何实现一个简单的倒排索引搜索引擎：

import java.util.*;

public class SimpleSearchEngine {
    // 倒排索引：term -> document IDs
    private Map<String, Set<Integer>> invertedIndex = new HashMap<>();
    // 文档内容存储
    private Map<Integer, String> documents = new HashMap<>();
    
    public void addDocument(int docId, String content) {
        documents.put(docId, content.toLowerCase());
        String[] words = content.toLowerCase().split("\\s+");
        
        for (String word : words) {
            if (!invertedIndex.containsKey(word)) {
                invertedIndex.put(word, new HashSet<>());
            }
            invertedIndex.get(word).add(docId);
        }
    }
    
    public List<Integer> search(String query) {
        String[] keywords = query.toLowerCase().split("\\s+");
        
        if (keywords.length == 0) {
            return new ArrayList<>();
        }
        
        // 找到包含第一个关键词的所有文档
        Set<Integer> result = new HashSet<>(invertedIndex.getOrDefault(keywords[0], new HashSet<>()));
        
        // 对后续关键词进行交集操作
        for (int i = 1; i < keywords.length; i++) {
            Set<Integer> docSet = invertedIndex.getOrDefault(keywords[i], new HashSet<>());
            result.retainAll(docSet);
        }
        
        return new ArrayList<>(result);
    }
}

这个简单的搜索引擎虽然功能有限，但它展示了倒排索引的核心思想。实际生产环境中的搜索引擎（如Elasticsearch）会在此基础上做很多优化，但基本原理是相同的。

---

学习建议：如何高效刷LeetCode

最后，我给你一些学习建议。

第一，不要贪多，要扎实。 我建议初学者先刷LeetCode热题100，这100道题涵盖了最常见的算法和数据结构题型。每道题不要只看答案，要自己动手写，理解每一步的逻辑。

第二，建立错题本。 我建议你用笔记本或者Notion建立一个错题本，把做错的题和经典题的分类整理好。每次复习的时候，先看错题，再看错题本中总结的解题思路。

第三，模拟面试环境。 很多初学者在面试时会紧张，导致平时会做的题也做不出来。建议你找朋友或者对着镜子模拟面试，限时完成题目，锻炼自己在压力下的思维能力。

第四，结合实际项目。 算法最终要应用到项目中才有价值。我建议你在学习算法的同时，也要做一些小项目，把学到的知识应用到实际中。比如用之前讲的缓存系统，做一个简单的新闻推荐系统；用排序算法，做一个简单的文件管理器。

第五，保持耐心和坚持。 算法学习是一个长期的过程，不可能一蹴而就。我建议你每天至少做一道题，保持手感。即使有时候做不出来，也不要气馁，多看几遍答案，理解思路，过几天再尝试自己做。

---

结语：算法是一场马拉松，不是短跑

最后我想说，学习算法最重要的是建立信心。第一次刷LeetCode的时候，我也曾经因为一道题卡了一整天而怀疑自己。但后来我发现，算法就像肌肉一样，越练越强。每做一道题，你的思维就更清晰一点，每掌握一种算法，你的视野就更广阔一点。

我希望这篇文章能帮你建立起算法学习的基本框架，从排序、查找、数据结构到动态规划，从LeetCode第一题到手撕面试真题，每一步都有详细的讲解和代码示例。如果你在学习中遇到任何问题，欢迎随时来找我交流。记住，学习算法的路上，你从来不是一个人。

加油，未来的算法工程师！