Javajava算法

LeetCode 热题 100 算法通关指南及代码模板

整理 LeetCode 热题 100 核心算法模板与解题思路。涵盖哈希、双指针、滑动窗口、链表、树、图论、动态规划等数据结构。提供 Java 代码实现，含关键心法、复杂度分析及经典例题。帮助开发者系统化掌握高频考点，提升刷题效率与编码能力。

刀狂发布于 2026/3/23更新于 2026/5/38 浏览

LeetCode 热题 100 算法通关指南及代码模板

1. 哈希 (Hash)

核心思想：利用哈希映射快速查找、统计频率或建立键值对应关系。
常用集合：哈希表（如 HashMap）。
口诀记忆：'一看配对就哈希，空间换时间是王道'
时间复杂度：查找 O(1)，构建 O(n)
空间复杂度：O(n)
心法与模板：
- 心法：一看到题目要求"查找"、"配对"、"计数，分组"，第一反应就是哈希表。它是用空间换时间的利器，能把 O(N²) 的暴力查找降到 O(N)。
经典题目：
- LeetCode 1: 两数之和（模板，学会边遍历边检查和 put 入 hashmap。不能直接把数组放入 hashmap 中（比如 put（3，2）会覆盖（3，1）））
- LeetCode 49: 字母异位词分组（模板，边遍历边检查，字母异位先变为数组，再排序，学会哈希用在分组上（键是有序字母，值分组，是数组））
- LeetCode 128: 最长连续序列（模板，一边遍历一边检查，找到开头非常关键！）

优化模板 (以"两数之和"为例)：

import java.util.*;

public int[] twoSum(int[] nums, int target) {
    // 边界检查
    if (nums == null || nums.length < 2) return new int[0];
    // 1. 创建哈希表
    Map<Integer, Integer> map = new HashMap<>();
    // 2. 遍历数组
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        // 3. 边遍历边检查
        if (map.containsKey(complement)) {
            // 重点！
            // 4. 找到，立即返回
            return  []{map.get(complement), i};
        }
        
        map.put(nums[i], i);
    }
    
      [];
}

public void moveZeroes(int[] nums) {
    int slow = 0; // slow 指向下一个非零元素要放置的位置
    for (int fast = 0; fast < nums.length; fast++) {
        if (nums[fast] != 0) {
            // 交换元素（更通用的写法）
            int temp = nums[slow];
            nums[slow] = nums[fast];
            nums[fast] = temp;
            slow++;
        }
    }
}

public int[] twoSumSorted(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) {
            // 找到了，根据题目要求处理
            return new int[]{left, right};
        } else if (sum < target) {
            left++; // 和太小，左指针右移增大和
        } else {
            right--; // 和太大，右指针左移减小和
        }
    }
    return new int[0]; // 未找到
}

public int lengthOfLongestSubstring(String s) {
    // 1. 初始化窗口和结果
    Map<Character, Integer> window = new HashMap<>();
    int left = 0, right = 0;
    int maxLen = 0;
    // 2. 右指针扩大窗口
    while (right < s.length()) {
        char c = s.charAt(right);
        right++;
        window.put(c, window.getOrDefault(c, 0) + 1);
        // 3. 具体的收缩条件：当窗口中有重复字符时
        while (window.get(c) > 1) {
            char d = s.charAt(left);
            left++;
            window.put(d, window.get(d) - 1);
        }
        maxLen = Math.max(maxLen, right - left);
    }
    return maxLen;
}

public int subarraySum(int[] nums, int k) {
    // 1. 初始化哈希表（记录每种前缀和出现的次数）
    Map<Integer, Integer> map = new HashMap<>();
    // 重要：初始化前缀和为 0 的出现 1 次
    map.put(0, 1);
    int preSum = 0;
    int count = 0;
    // 2. 遍历数组
    for (int num : nums) {
        preSum += num;
        // 3. 关键：查找符合条件的前缀和
        if (map.containsKey(preSum - k)) {
            count += map.get(preSum - k);
        }
        // 4. 将当前前缀和存入哈希表
        map.put(preSum, map.getOrDefault(preSum, 0) + 1);
    }
    return count;
}

public int firstMissingPositive(int[] nums) {
    int n = nums.length;
    // 1. 将所有数字放到它应该在的位置上
    for (int i = 0; i < n; i++) {
        while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
            int temp = nums[nums[i] - 1];
            nums[nums[i] - 1] = nums[i];
            nums[i] = temp;
        }
    }
    // 2. 再次遍历，找到第一个不在正确位置上的数字
    for (int i = 0; i < n; i++) {
        if (nums[i] != i + 1) {
            return i + 1;
        }
    }
    return n + 1;
}

public List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> result = new ArrayList<>();
    if (matrix == null || matrix.length == 0) return result;
    int top = 0, bottom = matrix.length - 1;
    int left = 0, right = matrix[0].length - 1;
    while (top <= bottom && left <= right) {
        for (int i = left; i <= right; i++) result.add(matrix[top][i]);
        top++;
        for (int i = top; i <= bottom; i++) result.add(matrix[i][right]);
        right--;
        if (top <= bottom) {
            for (int i = right; i >= left; i--) result.add(matrix[bottom][i]);
            bottom--;
        }
        if (left <= right) {
            for (int i = bottom; i >= top; i--) result.add(matrix[i][left]);
            left++;
        }
    }
    return result;
}

public ListNode universalTemplate(ListNode head) {
    // 1. 创建虚拟头节点，简化边界处理
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    // 2. 定义工作指针
    ListNode prev = dummy;
    ListNode curr = head;
    // 3. 遍历处理
    while (curr != null) {
        // ... 根据具体题目处理 curr 节点 ...
        // 标准前进步骤
        prev = curr;
        curr = curr.next;
    }
    // 4. 返回新的头节点
    return dummy.next;
}

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 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;
}

void traverse(TreeNode root) {
    if (root == null) return;
    // 前序位置
    System.out.println(root.val);
    traverse(root.left);
    // 后序位置
    traverse(root.right);
}

class Solution {
    List<List<Integer>> edges;
    int[] visited;
    boolean valid = true;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<>(numCourses);
        for (int i = 0; i < numCourses; i++) edges.add(new ArrayList<>());
        for (int[] info : prerequisites) edges.get(info[1]).add(info[0]);
        visited = new int[numCourses];
        for (int i = 0; i < edges.size() && valid; i++) {
            if (visited[i] == 0) dfs(i);
        }
        return valid;
    }

    private void dfs(int i) {
        if (visited[i] == 1) { valid = false; return; }
        if (visited[i] == 2) return;
        visited[i] = 1;
        for (int node : edges.get(i)) dfs(node);
        visited[i] = 2;
    }
}

public int bfs(int start, int target, Map<Integer, List<Integer>> graph) {
    Queue<Integer> queue = new LinkedList<>();
    Set<Integer> visited = new HashSet<>();
    queue.offer(start);
    visited.add(start);
    int steps = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            int node = queue.poll();
            if (node == target) return steps;
            for (int neighbor : graph.getOrDefault(node, new ArrayList<>())) {
                if (!visited.contains(neighbor)) {
                    visited.add(neighbor);
                    queue.offer(neighbor);
                }
            }
        }
        steps++;
    }
    return -1;
}

List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
boolean[] used;

void backtrack(int[] nums, int startIndex) {
    // 1. 终止条件
    if (path.size() == k) {
        result.add(new ArrayList<>(path));
        return;
    }
    // 2. 遍历选择列表
    for (int i = startIndex; i < nums.length; i++) {
        if (used[i]) continue;
        // 3. 做选择
        path.add(nums[i]);
        used[i] = true;
        // 4. 进入下一层决策树
        backtrack(nums, i + 1);
        // 5. 撤销选择
        path.removeLast();
        used[i] = false;
    }
}

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

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;
        if (target > nums[mid]) left = mid + 1;
        if (target < nums[mid]) right = mid - 1;
    }
    return -1;
}

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    Map<Character, Character> map = new HashMap<>();
    map.put(')', '(');
    map.put('}', '{');
    map.put(']', '[');
    for (char c : s.toCharArray()) {
        if (map.containsKey(c)) {
            if (stack.isEmpty() || !stack.pop().equals(map.get(c))) return false;
        } else {
            stack.push(c);
        }
    }
    return stack.isEmpty();
}

public int[] nextGreaterElement(int[] nums) {
    int[] result = new int[nums.length];
    Stack<Integer> stack = new Stack<>();
    for (int i = 0; i < nums.length; i++) {
        while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
            int prevIndex = stack.pop();
            result[prevIndex] = nums[i];
        }
        stack.push(i);
    }
    while (!stack.isEmpty()) {
        result[stack.pop()] = -1;
    }
    return result;
}

class MedianFinder {
    PriorityQueue<Integer> maxHeap; // 左半部分，大顶堆
    PriorityQueue<Integer> minHeap; // 右半部分，小顶堆

    public MedianFinder() {
        maxHeap = new PriorityQueue<>((a, b) -> b - a);
        minHeap = new PriorityQueue<>();
    }

    public void addNum(int num) {
        if (maxHeap.isEmpty() || num <= maxHeap.peek()) {
            maxHeap.offer(num);
        } else {
            minHeap.offer(num);
        }
        if (maxHeap.size() > minHeap.size() + 1) {
            minHeap.offer(maxHeap.poll());
        } else if (minHeap.size() > maxHeap.size()) {
            maxHeap.offer(minHeap.poll());
        }
    }

    public double findMedian() {
        if (maxHeap.size() == minHeap.size()) {
            return (maxHeap.peek() + minHeap.peek()) / 2.0;
        } else {
            return maxHeap.peek();
        }
    }
}

public List<Integer> topKLargest(int[] nums, int k) {
    PriorityQueue<Integer> minHeap = new PriorityQueue<>(k);
    for (int num : nums) {
        if (minHeap.size() < k) {
            minHeap.offer(num);
        } else if (num > minHeap.peek()) {
            minHeap.poll();
            minHeap.offer(num);
        }
    }
    return new ArrayList<>(minHeap);
}

public int eraseOverlapIntervals(int[][] intervals) {
    if (intervals.length == 0) return 0;
    Arrays.sort(intervals, (a, b) -> a[1] - b[1]);
    int count = 1;
    int end = intervals[0][1];
    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i][0] >= end) {
            count++;
            end = intervals[i][1];
        }
    }
    return intervals.length - count;
}

class Solution {
    public int numSquares(int n) {
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int i = 1; i * i <= n; i++) {
            int square = i * i;
            for (int j = square; j <= n; j++) {
                if (dp[j - square] != Integer.MAX_VALUE) {
                    dp[j] = Math.min(dp[j], dp[j - square] + 1);
                }
            }
        }
        return dp[n];
    }
}

public boolean wordBreak(String s, List<String> wordDict) {
    int n = s.length();
    boolean[] dp = new boolean[n + 1];
    dp[0] = true;
    Set<String> wordSet = new HashSet<>(wordDict);
    for (int i = 1; i <= n; i++) {
        for (String word : wordSet) {
            int wordLen = word.length();
            if (wordLen <= i && dp[i - wordLen] && s.substring(i - wordLen, i).equals(word)) {
                dp[i] = true;
                break;
            }
        }
    }
    return dp[n];
}

public int uniquePaths(int m, int n) {
    int[][] dp = new int[m][n];
    for (int i = 0; i < m; i++) dp[i][0] = 1;
    for (int j = 0; j < n; j++) dp[0][j] = 1;
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[m - 1][n - 1];
}

public int majorityElement(int[] nums) {
    int candidate = nums[0];
    int count = 1;
    for (int i = 1; i < nums.length; i++) {
        if (count == 0) {
            candidate = nums[i];
            count = 1;
        } else if (nums[i] == candidate) {
            count++;
        } else {
            count--;
        }
    }
    return candidate;
}

public int singleNumber(int[] nums) {
    int result = 0;
    for (int num : nums) {
        result ^= num;
    }
    return result;
}

public int strStr(String haystack, String needle) {
    if (needle.length() == 0) return 0;
    int[] next = new int[needle.length()];
    for (int i = 1, j = 0; i < needle.length(); i++) {
        while (j > 0 && needle.charAt(i) != needle.charAt(j)) j = next[j - 1];
        if (needle.charAt(i) == needle.charAt(j)) j++;
        next[i] = j;
    }
    for (int i = 0, j = 0; i < haystack.length(); i++) {
        while (j > 0 && haystack.charAt(i) != needle.charAt(j)) j = next[j - 1];
        if (haystack.charAt(i) == needle.charAt(j)) j++;
        if (j == needle.length()) return i - needle.length() + 1;
    }
    return -1;
}

class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    public void insert(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            if (node.children[c - 'a'] == null) node.children[c - 'a'] = new TrieNode();
            node = node.children[c - 'a'];
        }
        node.isEnd = true;
    }

    public boolean search(String word) {
        TrieNode node = searchPrefix(word);
        return node != null && node.isEnd;
    }

    public boolean startsWith(String prefix) {
        return searchPrefix(prefix) != null;
    }

    private TrieNode searchPrefix(String prefix) {
        TrieNode node = root;
        for (char c : prefix.toCharArray()) {
            if (node.children[c - 'a'] == null) return null;
            node = node.children[c - 'a'];
        }
        return node;
    }

    class TrieNode {
        TrieNode[] children = new TrieNode[26];
        boolean isEnd = false;
    }
}

class UnionFind {
    private int[] parent;
    private int[] rank;
    private int count;

    public UnionFind(int n) {
        parent = new int[n];
        rank = new int[n];
        count = n;
        for (int i = 0; i < n; i++) parent[i] = i;
    }

    public int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            if (rank[rootX] < rank[rootY]) parent[rootX] = rootY;
            else if (rank[rootX] > rank[rootY]) parent[rootY] = rootX;
            else { parent[rootY] = rootX; rank[rootX]++; }
            count--;
        }
    }

    public boolean connected(int x, int y) {
        return find(x) == find(y);
    }

    public int getCount() {
        return count;
    }
}

关键词	立刻想到	模板
'两数之和'、'配对'	哈希表	`map.containsKey(target - num)`
'有序数组'、'target'	双指针/二分	`left < right` 夹逼
'连续子串'、'最长/最短'	滑动窗口	`while (right < n)` 扩窗口
'链表环'、'中点'	快慢指针	`slow/fast` 经典
'二叉树遍历'	递归	`dfs(root.left), dfs(root.right)`
'全排列'、'组合'	回溯	`backtrack(path, choices)`
'第 K 大'、'Top K'	堆	`PriorityQueue`
'最优解'、'可能性'	动态规划	`dp[i] = max(dp[i-1], ...)`
'判断连通'	并查集/BFS	`find()`, `union()`
'布局/路径'	图论	BFS 寻最短路径
'位操作'	异或	`a ^ a = 0`

LeetCode 热题 100 算法通关指南及代码模板

LeetCode 热题 100 算法通关指南及代码模板

1. 哈希 (Hash)

LeetCode 热题 100 算法通关指南及代码模板

LeetCode 热题 100 算法通关指南及代码模板

1. 哈希 (Hash)

更多推荐文章

相关免费在线工具

2. 双指针 (Two Pointers)

3. 滑动窗口 (Sliding Window)

4. 子串 (Substring)

5. 普通数组 (Array)

6. 矩阵 (Matrix)

7. 链表 (Linked List)

8. 二叉树 (Binary Tree)

9. 图论 (Graph)

10. 回溯 (Backtracking)

11. 二分查找 (Binary Search)

12. 栈 (Stack)

13. 堆 (Heap)

14. 贪心算法 (Greedy)

15 & 16. 动态规划 (DP)

17. 技巧 (Tricks)

18. 字符串算法 (String)

19. 并查集 (Union Find)

学习路线图

第一阶段：基础算法与数据结构

第二阶段：链表与树

第三阶段：进阶数据结构

第四阶段：进阶算法

第五阶段：高级算法

快速学习加速技巧

口诀记忆总结

30 秒快速识别表

更多推荐文章

相关免费在线工具

LeetCode 热题 100 算法通关指南及代码模板

LeetCode 热题 100 算法通关指南及代码模板

1. 哈希 (Hash)

LeetCode 热题 100 算法通关指南及代码模板

LeetCode 热题 100 算法通关指南及代码模板

1. 哈希 (Hash)

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

2. 双指针 (Two Pointers)

3. 滑动窗口 (Sliding Window)

4. 子串 (Substring)

5. 普通数组 (Array)

6. 矩阵 (Matrix)

7. 链表 (Linked List)

8. 二叉树 (Binary Tree)

9. 图论 (Graph)

10. 回溯 (Backtracking)

11. 二分查找 (Binary Search)

12. 栈 (Stack)

13. 堆 (Heap)

14. 贪心算法 (Greedy)

15 & 16. 动态规划 (DP)

17. 技巧 (Tricks)

18. 字符串算法 (String)

19. 并查集 (Union Find)

学习路线图

第一阶段：基础算法与数据结构

第二阶段：链表与树

第三阶段：进阶数据结构

第四阶段：进阶算法

第五阶段：高级算法

快速学习加速技巧

口诀记忆总结

30 秒快速识别表

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具