面试整理——算法

发表于 更新于 分类于
本文字数： 484k 阅读时长 ≈ 7:20
整理面试中常问的算法相关问题，持续更新中。

算法

一.综合

Leetcode解题方法记录

数组/字符串
难度 题目 解题方法
easy 88.合并两个有序数组 逆向双指针倒序循环将元素合并入nums1，循环后收尾nums2剩余
easy 27. 移除元素 双指针，循环指针遍历数组，另一个指针只在元素不同时交换元素，该指针就是最终结果
easy 26. 删除有序数组中的重复项 双指针，元素相等时j不动，不等时将i与j+1交换，从而留下一个j
medium 80. 删除有序数组中的重复项 II 双指针，因为保留2个重复元素，所以从2开始，每次判断i和j-2是否相等，若不等表示i元素要保留，和j交换，并j++更新j。j代表着留下的元素。
链表
难度 题目 解题方法
easy 141. 环形链表 快慢指针
medium 2.两数相加 同时遍历两个链表，逐位相加
easy 21. 合并两个有序链表 同时遍历两个链表，分别判断节点各种情况
medium 138. 随机链表的复制 用Map提前生成复制节点，二次遍历copy连接
medium 92. 反转链表 II 指定区间反转，压栈；或者使用reverse直接反转链表
medium 143. 重排链表 快慢指针定位中部，再reverse反转
hard 25. K 个一组翻转链表 每k个一组反转，每轮反转要记住反转的头尾，再reverse反转
medium 19. 删除链表的倒数第 N 个结点 快慢指针，快指针先移动n个节点，然后快慢指针一起移动，快指针到达尾部时，慢指针到达要删除的节点
medium 82. 删除排序链表中的重复元素 II 双层循环，记录prev、curr、next，直到找到所有重复元素
medium 61. 旋转链表 先遍历长度再对k求余可以避免重复循环
medium 86. 分隔链表 用两个指针分别代表小于和大于等于x的链表，循环后注意连接两个链表，并且断开新的large链表尾部的next连接
medium 146. LRU 缓存 通过双向链表来存放使用记录，Map<key, Node>来记录键值对，每次使用时先removeNode，再addToFront，新增时若超容量则删除tail前一个节点即最久为使用
hard 460. LFU缓存 双向链表+HashMap来实现。记录minFreq，通过一个Map来存放键值对用于快速访问，然后另一个Map<Int Freq, DoubleLinkedList> 记录每个频率的节点，双向链表表示LRU，用于淘汰相同频率节点。
一维动态规划
难度 题目 解题方法
easy 70. 爬楼梯 d[i] = d[i-1] + d[i-2]
medium 198. 打家劫舍 dp[i] = Max(dp[i-1], dp[i-2] + nums[i-1])
medium 139. 单词拆分 dp[i] = dp[i-len] & s.substring(i - len, i).equals(word)
medium 322. 零钱兑换 dp[i] = Math.min(dp[i-coin] + 1, dp[i])
medium 300. 最长递增子序列 dp[i] = Math.max(dp[i], dp[j] + 1)

问：讲下常见的排序算法及其复杂度？怎么实现一个快排？

1. 常见排序算法及其复杂度

排序算法 时间复杂度（平均） 时间复杂度（最坏） 时间复杂度（最好） 空间复杂度 稳定性
冒泡排序 O(n^2) O(n^2) O(n) O(1) 稳定
选择排序 O(n^2) O(n^2) O(n^2) O(1) 不稳定
插入排序 O(n^2) O(n^2) O(n) O(1) 稳定
归并排序 O(nlog⁡n) O(nlog⁡n) O(nlog⁡n) O(n) 稳定
快速排序 O(nlog⁡n) O(n^2) O(nlog⁡n) O(log⁡n) 不稳定
堆排序 O(nlog⁡n) O(nlog⁡n) O(nlog⁡n) O(1) 不稳定
计数排序 O(n+k) O(n+k) O(n+k)O(n+k) O(k) 稳定
桶排序 O(n+k) O(n^2) O(n+k)O(n+k) O(n+k) 稳定
基数排序 O(d⋅(n+k)) O(d⋅(n+k)) O(d⋅(n+k)) O(n+k) 稳定

2. 快速排序（Quick Sort）实现

快速排序是基于分治思想的排序算法。它选择一个”基准”元素，将数组分为两部分：一部分比基准小，一部分比基准大，然后递归地对两部分进行排序。

  1. 选择一个基准（pivot）。
  2. 将数组分成两部分：小于基准和大于基准。
  3. 递归地对两部分排序。

代码实现（Java）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class QuickSort {

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

    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[right]; // 选择最后一个元素作为基准
        int i = left - 1;       // i 指向小于 pivot 的最后一个元素
        for (int j = left; j < right; j++) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, right); // 把 pivot 放到正确的位置
        return i + 1;            // 返回基准元素的索引
    }

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

    public static void main(String[] args) {
        int[] arr = {8, 3, 5, 4, 7, 6, 1, 2};
        quickSort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

时间复杂度：

  • 最坏情况：O(n^2)（当数组是有序的，基准总是最小/最大值）
  • 平均情况：O(nlog⁡n)
  • 最好情况：O(nlog⁡n)

空间复杂度：

  • O(log⁡n)（递归栈空间）

冒泡排序（Bubble Sort）

  1. 比较相邻的元素，如果顺序错误就交换它们。
  2. 每一轮将最大的元素“冒泡”到末尾。
  3. 重复 n−1 轮，直到整个数组有序。

复杂度

  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) { // 交换相邻元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) break; // 若无交换，提前结束
        }
    }
}

选择排序（Selection Sort）

  1. 每轮从未排序部分选择最小的元素，放到已排序部分的末尾。
  2. 重复 n−1 轮，最终数组有序。

复杂度

  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换最小值到当前位置
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

插入排序（Insertion Sort）

  1. 将数组分为已排序和未排序部分。
  2. 从未排序部分选取元素，插入到已排序部分的正确位置。
  3. 重复直到整个数组有序。

复杂度

  • 时间复杂度：O(n^2)（最好：O(n)，当数组接近有序）
  • 空间复杂度：O(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            // 将比 key 大的元素右移
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key; // 插入元素到正确位置
        }
    }
}

归并排序（Merge Sort）

  1. 将数组分成两部分，递归地对两部分排序。
  2. 合并两个已排序数组。

复杂度

  • 时间复杂度：O(nlog⁡n)
  • 空间复杂度：O(n)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class MergeSort {
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            // 递归排序左边
            mergeSort(arr, left, mid);
            // 递归排序右边
            mergeSort(arr, mid + 1, right);
            // 合并两边
            merge(arr, left, mid, right);
        }
    }

    private static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;

        int[] leftArr = new int[n1];
        int[] rightArr = new int[n2];

        // 复制两边数组
        System.arraycopy(arr, left, leftArr, 0, n1);
        System.arraycopy(arr, mid + 1, rightArr, 0, n2);

        int i = 0, j = 0, k = left;
        // 双指针分别遍历两个集合，按顺序放回原集合
        while (i < n1 && j < n2) {
            if (leftArr[i] <= rightArr[j]) {
                arr[k++] = leftArr[i++];
            } else {
                arr[k++] = rightArr[j++];
            }
        }
        while (i < n1) arr[k++] = leftArr[i++];
        while (j < n2) arr[k++] = rightArr[j++];
    }
}

堆排序（Heap Sort）

  1. 构建一个大根堆。
  2. 每次取堆顶元素（最大值），放到数组末尾。
  3. 调整堆，重复直到数组有序。

复杂度

  • 时间复杂度：O(nlog⁡n)
  • 空间复杂度：O(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class HeapSort {
    public static void heapSort(int[] arr) {
        int n = arr.length;

        // 第一步：构造大根堆（Heapify过程）
        // 从最后一个非叶子节点开始，向上调整堆
        // 非叶子节点的索引是 n/2 - 1
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }
        // 第二步：交换堆顶和数组末尾元素，并重新调整堆
        for (int i = n - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            
            // 调整剩余部分为新的大根堆
            // 注意此时堆的大小减少了1，范围是 [0, i-1]
            heapify(arr, i, 0);
        }
    }

    // 辅助函数：调整堆
    private static void heapify(int[] arr, int n, int i) {
        int largest = i; // 假设当前节点 i 是最大值
        int left = 2 * i + 1; // 左子节点索引
        int right = 2 * i + 2; // 右子节点索引

        // 检查左子节点是否存在且是否大于当前最大值
        if (left < n && arr[left] > arr[largest]) largest = left;
        // 检查右子节点是否存在且是否大于当前最大值
        if (right < n && arr[right] > arr[largest]) largest = right;

        // 如果最大值不是当前节点 i，则需要交换并递归调整
        if (largest != i) {
            // 交换当前节点和最大值节点
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;
            // 递归调整受影响的子树
            heapify(arr, n, largest);
        }
    }
}

问：二分查找？

二分查找是一种 高效的查找算法，用于 有序数组 或 单调性问题，时间复杂度为 **O(log n)**。

  • 在有序数组中，选择中间元素mid作为比较基准：
    • 如果 target == arr[mid]，返回 mid（找到目标值）。
    • 如果 target < arr[mid]，说明 target 可能在 左半部分，递归或迭代缩小搜索范围 right = mid - 1。
    • 如果 target > arr[mid]，说明 target 可能在 右半部分，缩小搜索范围 left = mid + 1。
  • 重复该过程，直到找到目标值或 搜索区间为空（left > right）。

代码实现

（1）标准二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class BinarySearch {
    public int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        while (left <= right) { 
            int mid = left + (right - left) / 2; // 防止溢出
            if (arr[mid] == target) {
                return mid; // 找到目标值，返回索引
            } else if (arr[mid] < target) {
                left = mid + 1; // 目标值在右侧
            } else {
                right = mid - 1; // 目标值在左侧
            }
        }
        return -1; // 未找到
    }

    public static void main(String[] args) {
        BinarySearch bs = new BinarySearch();
        int[] arr = {1, 3, 5, 7, 9, 11, 15};
        System.out.println(bs.binarySearch(arr, 7)); // 输出 3（索引位置）
        System.out.println(bs.binarySearch(arr, 6)); // 输出 -1（未找到）
    }
}

时间复杂度：O(log n)
空间复杂度：O(1)（迭代实现，不使用额外空间）

递归版二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class RecursiveBinarySearch {
    public int binarySearch(int[] arr, int left, int right, int target) {
        if (left > right) return -1; // 终止条件
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid; // 找到目标值
        if (arr[mid] > target) return binarySearch(arr, left, mid - 1, target);
        return binarySearch(arr, mid + 1, right, target);
    }

    public static void main(String[] args) {
        RecursiveBinarySearch rbs = new RecursiveBinarySearch();
        int[] arr = {1, 3, 5, 7, 9, 11, 15};
        System.out.println(rbs.binarySearch(arr, 0, arr.length - 1, 9)); // 输出 4
    }
}

时间复杂度：O(log n)
空间复杂度：O(log n)（递归调用栈的开销）

变种二分查找

（1）查找 target 的 “左边界”（Lower Bound）

目标：找到 target 最左侧出现的位置（如果存在），否则返回 插入位置（第一个比 target 大的位置）。

1
2
3
4
5
6
7
8
9
10
11
12
public int lowerBound(int[] arr, int target) {
    int left = 0, right = arr.length;
    while (left < right) { // 注意这里是 `<` 而不是 `<=`
        int mid = left + (right - left) / 2;
        if (arr[mid] >= target) {
            right = mid; // `target` 可能在左侧
        } else {
            left = mid + 1; // `target` 在右侧
        }
    }
    return left;
}

示例

1
2
3
int[] arr = {1, 3, 3, 5, 7, 7, 9};
System.out.println(lowerBound(arr, 7)); // 输出 4
System.out.println(lowerBound(arr, 6)); // 输出 4（6 不存在，返回插入点）

（2）查找 target 的 “右边界”（Upper Bound）

目标：找到 target 最右侧出现的位置的右边（比 target 大的第一个数的索引）。

1
2
3
4
5
6
7
8
9
10
11
12
public int upperBound(int[] arr, int target) {
    int left = 0, right = arr.length;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] > target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

示例

1
2
3
int[] arr = {1, 3, 3, 5, 7, 7, 9};
System.out.println(upperBound(arr, 7)); // 输出 6（索引 6 是 9）
System.out.println(upperBound(arr, 6)); // 输出 4（插入位置）

适用场景

✅ 适用于：

  1. 有序数组 查找
  2. 查找插入位置（lower_bound、upper_bound）
  3. 搜索区间问题（如找出第一个/最后一个 >= target 的位置）
  4. 二分答案问题（如最小化最大值、最大化最小值等）

❌ 不适用于：

  1. 无序数组
  2. 非单调函数
  3. 数据结构非数组（链表等无法随机访问）

二.数据结构

问：树一般怎么实现，链表怎么实现？

树的一般实现

  • 树可以用链式存储（指针）或数组存储实现。

  • 链式存储（常用）：

    每个节点包含数据和指向子节点的指针。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class TreeNode {
        int value;
        TreeNode left;
        TreeNode right;

        public TreeNode(int value) {
            this.value = value;
            this.left = null;
            this.right = null;
        }
    }

  • 数组存储（用于完全二叉树）：

    将节点按层次顺序存储到数组中。

    • 左子节点索引：2i + 1
    • 右子节点索引：2i + 2
    • 父节点索引：(i−1)/2

链表的一般实现

  • 链表是一组通过指针相互连接的节点，可分为单向链表、双向链表、循环链表等。

  • 单向链表：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class ListNode {
        int value;
        ListNode next;

        public ListNode(int value) {
            this.value = value;
            this.next = null;
        }
    }

  • 双向链表：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class DoublyListNode {
        int value;
        DoublyListNode prev;
        DoublyListNode next;

        public DoublyListNode(int value) {
            this.value = value;
            this.prev = null;
            this.next = null;
        }
    }

    链表在实现上较简单，适合需要频繁插入和删除的场景，但在随机访问上性能较差（需要 O(n) 时间）。

问：堆是怎么实现？小根堆如何插入数据，讲一下过程？

  • 堆的实现

    堆是一种特殊的完全二叉树，满足以下两个条件：

    1. 结构特性：堆是完全二叉树，即除了最后一层外，其余层是满的，并且最后一层的节点靠左对齐。
    2. 堆序特性：
      • 大根堆：每个节点的值都大于或等于其子节点的值。
      • 小根堆：每个节点的值都小于或等于其子节点的值。

    堆可以通过数组或链表实现。一般使用数组实现更常见。

    1. 大根堆（最大堆）：每个节点的值都大于等于其子节点的值。
    2. 小根堆（最小堆）：每个节点的值都小于等于其子节点的值。

  • 堆的数组实现

    对于堆中第 i 个节点：

    • 父节点索引：(i - 1) / 2
    • 左子节点索引：2i + 1
    • 右子节点索引：2i + 2

    假设我们有一个数组：[3, 5, 1, 8, 4, 7, 2] 将其构造成一个大根堆。

    1. 步骤 1：从最后一个非叶子节点开始

      对于完全二叉树，非叶子节点从 ⌊n/2⌋−1 开始：

      • 数组长度 n=7，所以最后一个非叶子节点索引为 ⌊7/2⌋−1=2。

      从索引 2 开始调整：

      • 当前节点：1（索引 2）
      • 左子节点：7（索引 5）
      • 右子节点：2（索引 6）

      比较当前节点和子节点：

      • 最大值是左子节点 7，交换当前节点 1 和 7。

      调整后数组：[3, 5, 7, 8, 4, 1, 2]

    2. 步骤 2：继续向上调整

      调整索引 1 的子树：

      • 当前节点：5（索引 1）
      • 左子节点：8（索引 3）
      • 右子节点：4（索引 4）

      比较当前节点和子节点：

      • 最大值是左子节点 8，交换当前节点 5 和 8。

      调整后数组：[3, 8, 7, 5, 4, 1, 2]

      调整索引 0 的子树：

      • 当前节点：3（索引 0）
      • 左子节点：8（索引 1）
      • 右子节点：7（索引 2）

      比较当前节点和子节点：

      • 最大值是左子节点 8，交换当前节点 3 和 8。

      调整后数组：[8, 3, 7, 5, 4, 1, 2]

      然后递归调整改变后节点3的子树，左节点为5，右节点为4，交换3和5。

    3. 最终大根堆：

    1
    [8, 5, 7, 3, 4, 1, 2]

  • 小根堆插入数据的过程

    插入一个数据到小根堆中需要遵循以下步骤：

    1. 将新数据放入堆的末尾。

    2. 上浮调整：

      • 将新数据和其父节点进行比较。
      • 如果新数据小于父节点，则交换两者的位置。
      • 继续比较新数据与新的父节点，重复这一过程，直到满足小根堆的性质。

    插入示例

    假设小根堆为：

    1
    2
    3
    4
    5
         2
       /   \
      5     10
     / \
    8   7

    数组表示为：[2, 5, 10, 8, 7]

    插入新数据 1：

    1. 将 1 放到堆末尾：[2, 5, 10, 8, 7, 1]

    2. 上浮调整：

      • 1 的父节点是 10（索引 2），比较 1 和 10：1 < 10，交换。
      • 现在堆为：[2, 5, 1, 8, 7, 10]
      • 1 的新父节点是 2（索引 0），比较 1 和 2：1 < 2，交换。
      • 最终堆为：[1, 5, 2, 8, 7, 10]

    调整后的堆：

    1
    2
    3
    4
    5
    6
    7
         1
       /   \
      5     2
     / \
    8   7
         \
         10

  • 代码实现（Java）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.util.ArrayList;

class MinHeap {
    private ArrayList<Integer> heap;

    public MinHeap() {
        this.heap = new ArrayList<>();
    }

    // 插入元素
    public void insert(int value) {
        heap.add(value); // 将新元素添加到末尾
        int currentIndex = heap.size() - 1;

        // 上浮调整
        while (currentIndex > 0) {
            int parentIndex = (currentIndex - 1) / 2;
            if (heap.get(currentIndex) < heap.get(parentIndex)) {
                swap(currentIndex, parentIndex);
                currentIndex = parentIndex;
            } else {
                break;
            }
        }
    }

    // 交换元素
    private void swap(int i, int j) {
        int temp = heap.get(i);
        heap.set(i, heap.get(j));
        heap.set(j, temp);
    }

    // 打印堆
    public void printHeap() {
        System.out.println(heap);
    }

    public static void main(String[] args) {
        MinHeap minHeap = new MinHeap();
        minHeap.insert(2);
        minHeap.insert(5);
        minHeap.insert(10);
        minHeap.insert(8);
        minHeap.insert(7);
        minHeap.insert(1); // 插入 1
        minHeap.printHeap(); // 输出：[1, 5, 2, 8, 7, 10]
    }
}

时间复杂度

  • 插入：O(log⁡n)，因为上浮操作最多需要调整堆的高度。
  • 空间复杂度：O(1)，使用了原地调整，不需要额外空间。

总结

  • 小根堆的插入通过末尾插入数据并上浮调整，保证堆的性质。
  • 堆的实现多使用数组，便于索引计算。
  • 插入操作的效率高，适用于动态调整的数据结构场景（如优先队列、最小生成树等）。

问：判断链表是否有环？

判断链表是否有环通常使用快慢指针法（Floyd 判圈算法），该方法高效且不需要额外空间。

算法思路

  1. 设置两个指针：
    • 慢指针（slow）：每次移动一步。
    • 快指针（fast）：每次移动两步。
  2. 两个指针同时从链表头开始遍历：
    • 如果链表中有环，快指针最终会追上慢指针，出现相遇的情况。
    • 如果链表无环，快指针会走到链表的末尾（null），跳出循环。
  3. 如果快指针和慢指针相遇，说明链表有环。
  4. 如果快指针走到链表末尾，说明链表无环。

代码实现（Java）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class ListNode {
    int value;
    ListNode next;

    public ListNode(int value) {
        this.value = value;
        this.next = null;
    }
}

public class LinkedListCycle {

    // 判断链表是否有环
    public static boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) {
            return false; // 空链表或单节点链表不可能有环
        }

        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; // 快指针到达链表末尾，说明无环
    }

    public static void main(String[] args) {
        // 构造测试链表
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = head.next; // 创建环

        System.out.println(hasCycle(head)); // 输出 true

        // 无环链表测试
        ListNode head2 = new ListNode(1);
        head2.next = new ListNode(2);
        head2.next.next = new ListNode(3);
        System.out.println(hasCycle(head2)); // 输出 false
    }
}

时间复杂度

  • 时间复杂度：O(n)，其中 n是链表的节点数。

    • 每个节点最多被访问两次：一次由慢指针，另一次由快指针。

  • 空间复杂度：O(1)，只使用了两个指针，不需要额外空间。

扩展：找到环的起始节点

在判断链表有环的基础上，如果要找到环的起始节点，可以在相遇后：

  1. 将慢指针重置为链表头。
  2. 两个指针以相同速度移动（每次一步）。
  3. 两指针相遇时，即为环的起始节点。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static ListNode detectCycleStart(ListNode head) {
    if (head == null || head.next == null) {
        return null;
    }

    ListNode slow = head;
    ListNode fast = head;

    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;

        if (slow == fast) { // 有环
            slow = head; // 慢指针回到头部
            while (slow != fast) {
                slow = slow.next;
                fast = fast.next;
            }
            return slow; // 相遇点即为环的起始节点
        }
    }

    return null; // 无环
}

总结

  1. 判断有环：使用快慢指针法。
  2. 找到环起始点：在有环的基础上，通过双指针重置和移动实现。
  3. 时间复杂度：O(n)，空间复杂度：O(1)。

问：树的前序、中序、后序遍历？

树的遍历方式分为前序遍历、中序遍历和后序遍历，它们的主要区别在于访问当前节点的顺序相对于其左右子节点的顺序。以二叉树为例，具体如下：

1. 前序遍历 (Pre-order Traversal)

访问顺序：根节点 → 左子树 → 右子树

  • 逻辑：
    1. 访问当前节点。
    2. 前序遍历左子树。
    3. 前序遍历右子树。
  • 特点：
    • 可以用于复制树结构。
    • 根节点总是第一个被访问。
  • 递归代码：
1
2
3
4
5
6
7
8
public void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    System.out.print(root.val + " "); // 访问当前节点
    preOrder(root.left);             // 遍历左子树
    preOrder(root.right);            // 遍历右子树
}
  • 非递归代码 (使用栈)：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void preOrderIterative(TreeNode root) {
    if (root == null) {
        return;
    }
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        System.out.print(node.val + " "); // 访问当前节点
        if (node.right != null) {
            stack.push(node.right);      // 先压入右子节点
        }
        if (node.left != null) {
            stack.push(node.left);       // 再压入左子节点
        }
    }
}

2. 中序遍历 (In-order Traversal)

访问顺序：左子树 → 根节点 → 右子树

  • 逻辑：
    1. 中序遍历左子树。
    2. 访问当前节点。
    3. 中序遍历右子树。
  • 特点：
    • 二叉搜索树的中序遍历结果是有序的。
    • 常用于树的排序输出。
  • 递归代码：
1
2
3
4
5
6
7
8
public void inOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    inOrder(root.left);              // 遍历左子树
    System.out.print(root.val + " "); // 访问当前节点
    inOrder(root.right);             // 遍历右子树
}
  • 非递归代码 (使用栈)：
1
2
3
4
5
6
7
8
9
10
11
12
13
public void inOrderIterative(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode current = root;
    while (current != null || !stack.isEmpty()) {
        while (current != null) {
            stack.push(current);      // 压入当前节点
            current = current.left;   // 移动到左子树
        }
        current = stack.pop();        // 弹出栈顶节点
        System.out.print(current.val + " "); // 访问当前节点
        current = current.right;      // 移动到右子树
    }
}

3. 后序遍历 (Post-order Traversal)

访问顺序：左子树 → 右子树 → 根节点

  • 逻辑：
    1. 后序遍历左子树。
    2. 后序遍历右子树。
    3. 访问当前节点。
  • 特点：
    • 常用于删除树或释放内存，保证子节点在父节点之前被访问。
    • 顺序上与深度优先搜索的回溯过程类似。
  • 递归代码：
1
2
3
4
5
6
7
8
public void postOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    postOrder(root.left);            // 遍历左子树
    postOrder(root.right);           // 遍历右子树
    System.out.print(root.val + " "); // 访问当前节点
}
  • 非递归代码 (使用栈)：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void postOrderIterative(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode lastVisited = null;
    TreeNode current = root;
    while (current != null || !stack.isEmpty()) {
        while (current != null) {
            stack.push(current);      // 压入当前节点
            current = current.left;   // 移动到左子树
        }
        TreeNode peekNode = stack.peek(); // 查看栈顶节点
        if (peekNode.right != null && lastVisited != peekNode.right) {
            current = peekNode.right;    // 右子树未访问过，转向右子树
        } else {
            System.out.print(peekNode.val + " "); // 访问当前节点
            lastVisited = stack.pop();   // 弹出栈顶节点
        }
    }
}

三种遍历方式总结

遍历方式 访问顺序 应用场景
前序遍历 根 → 左 → 右 树的复制、表达式构建
中序遍历 左 → 根 → 右 二叉搜索树排序
后序遍历 左 → 右 → 根 树的删除、表达式求值

示例

假设二叉树如下：

1
2
3
4
5
6
7
8
9
10
11
12
    1
   / \
  2   3
 / \
4   5


    1
   / \
  2   3
   \  / \
    4 5  6

遍历结果：

  • 前序遍历： 1 2 4 5 3
  • 中序遍历： 4 2 5 1 3
  • 后序遍历： 4 5 2 3 1

遍历结果：

  • 前序遍历： 1 2 4 3 5 6
  • 中序遍历： 2 4 1 5 3 6
  • 后序遍历： 4 2 5 6 3 1

问：非递归且不用额外空间（不用栈），如何遍历二叉树？

要实现非递归、不使用额外空间（不用栈）遍历二叉树，可以采用 Morris 遍历，它通过修改树的结构来进行遍历，最终恢复树的原状。

Morris 中序遍历

  1. 核心思想：

    • 利用二叉树中的空闲左子树指针，将其临时指向前驱节点。
    • 通过这个链接，实现沿着树结构的遍历，而无需额外栈空间。

  2. 步骤：

    1. 初始化当前节点 cur 为根节点。

    2. 如果 cur 没有左子树：

      • 访问当前节点。
      • 移动到右子树。

    3. 如果 cur 有左子树：

      • 找到 cur 的左子树中的最右节点（即前驱节点 pre）。

      • 如果 pre 的右指针为空：

        • 将 pre 的右指针指向 cur（建立临时链接）。
        • 移动到左子树。

      • 如果 pre 的右指针已经指向 cur ：

        • 断开临时链接。
        • 访问当前节点。
        • 移动到右子树。

    4. 重复直到 cur 为 null。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public void morrisInorderTraversal(TreeNode root) {
    TreeNode cur = root;
    while (cur != null) {
        if (cur.left == null) {
            System.out.print(cur.val + " "); // 访问当前节点
            cur = cur.right;
        } else {
            TreeNode pre = cur.left;
            while (pre.right != null && pre.right != cur) {
                pre = pre.right; // 找前驱节点
            }
            if (pre.right == null) {
                pre.right = cur; // 建立链接
                cur = cur.left;
            } else {
                pre.right = null; // 断开链接
                System.out.print(cur.val + " "); // 访问当前节点
                cur = cur.right;
            }
        }
    }
}

时间和空间复杂度

  • 时间复杂度：O(n)，每个节点最多被访问两次。
  • 空间复杂度：O(1)，不使用额外的栈或递归。

类似地，可以调整访问顺序实现 Morris 的前序遍历和后序遍历。

问：二叉树的深度优先搜素和广度优先搜素？

1. 深度优先搜索（DFS）

深度优先搜索（Depth-First Search，简称 DFS）是一种递归或使用栈的方式遍历树结构，优先沿着树的深度遍历，直到叶子节点后再回溯。

常见的三种DFS遍历方式（即二叉树的遍历方式）：

  1. 前序遍历（Preorder: 根 -> 左 -> 右）
  2. 中序遍历（Inorder: 左 -> 根 -> 右）
  3. 后序遍历（Postorder: 左 -> 右 -> 根）

递归实现 DFS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int x) { val = x; }
}

public class TreeDFS {
    // 前序遍历（根 -> 左 -> 右）
    public void preOrder(TreeNode root) {
        if (root == null) return;
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    // 中序遍历（左 -> 根 -> 右）
    public void inOrder(TreeNode root) {
        if (root == null) return;
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

    // 后序遍历（左 -> 右 -> 根）
    public void postOrder(TreeNode root) {
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }
}

非递归实现 DFS（使用栈）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.Stack;

public class TreeDFSIterative {
    public void preOrder(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.val + " ");
            if (node.right != null) stack.push(node.right);
            if (node.left != null) stack.push(node.left);
        }
    }
}

📌 DFS 特点：

  • 递归实现简单，但可能会导致栈溢出（当树过深）。
  • 非递归使用栈模拟递归，适合处理大规模数据。

2. 广度优先搜索（BFS）

广度优先搜索（Breadth-First Search，简称 BFS）是一种逐层遍历的方法，通常使用队列（Queue） 实现。

BFS 通常用于：

  • 层序遍历
  • 最短路径搜索（例如最短路径问题）
  • 求二叉树的最小深度

BFS 代码实现（层序遍历）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.LinkedList;
import java.util.Queue;

public class TreeBFS {
    public void levelOrder(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.val + " ");
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
    }
}

📌 BFS 特点：

  • 使用 队列（FIFO），从上到下、从左到右逐层遍历。
  • 适用于 最短路径搜索，因为 BFS 会先访问较近的节点。

DFS 和 BFS 的比较

比较项 DFS（深度优先搜索） BFS（广度优先搜索）
数据结构 栈（递归或手动使用栈） 队列
适用于 1. 树的遍历（前/中/后序遍历） 2. 需要深入探索的搜索问题（如回溯） 1. 层序遍历 2. 最短路径问题
时间复杂度 O(N) O(N)
空间复杂度 O(h)（h为树高，最坏 O(N)） O(N)（存储所有节点）
访问顺序 沿深度优先遍历（优先访问叶子节点） 按层遍历（优先访问广度上的节点）
适用于 1. 需要遍历所有路径的情况2. 解决回溯问题（如八皇后） 1. 求解最短路径问题2. 层次遍历问题

4. 示例分析

1
2
3
4
5
    1
   / \
  2   3
 / \   \
4   5   6
  • DFS（前序遍历）： 1 → 2 → 4 → 5 → 3 → 6
  • BFS（层序遍历）： 1 → 2 → 3 → 4 → 5 → 6

问：讲讲红黑树？如何计算红黑树的时间复杂度？

红黑树算法：

平衡二叉树算法：插入时，需要判断是否会破坏树的平衡性，若是则要找到最小不平衡树，通过相应的旋转调整最小不平衡树中各个结点的关系，使其再度平衡。平衡因子就是左子树深度和右子树深度的差值，只能为-1、0、1。当最小不平衡子树的平衡因子和其子树的平衡因子符号相反时，要对结点先进行一次旋转使符号相同，再反向旋转一次完成平衡操作。

红黑树的时间复杂度：TODO

  • 红黑树通过严格的规则保证了高度平衡，确保操作复杂度为 O(log⁡n)。
  • 它被广泛用于实现集合、映射等数据结构（如 Java 的 TreeMap 和 TreeSet）。

  • 什么是红黑树？

    • 红黑树是一种 自平衡二叉查找树，确保在最坏情况下基本操作（如插入、删除和查找）的时间复杂度为 O(log⁡n)。它是一种二叉树，其中每个节点存储一个额外的“颜色”属性（红或黑），并通过规则维持树的平衡。

  • 核心：

    1. 节点颜色：每个节点要么是红色，要么是黑色。颜色表示父节点指向该节点的链接颜色。
    2. 根节点黑色：根节点始终是黑色。
    3. 红色节点：
      • 红色节点表示可以暂时不满足二叉树的平衡性。
      • 红色左连接使当前红节点与其父黑节点合并为2-3树的3节点。红黑树拉平就是一个2-3树。
      • 红色节点的子节点必须是黑色（不能有两个连续的红色节点）。
      • 新增的节点默认为红色（不影响黑高）
    4. 黑高平衡：从任意节点到其每个叶子节点的所有路径，包含相同数量的黑色节点。
    5. 叶节点（NIL）黑色：树的每个叶子节点（空节点）都是黑色。

  • 优点：

    • 自平衡性：通过严格的规则，确保树的高度接近最小高度，避免性能退化成链表。
    • 动态操作高效性：支持快速插入、删除、查找等操作。

  • 基础操作：

    1. 旋转操作：
      • 某些操作后会出现红色右链接或者两条连续的红链接
      • 左旋：用于调整右倾的红链接。以红色右链接的父节点为中心，将其右子树提升为新的根，原节点变为新根的左子节点，新根的原左子节点变为原节点的新右子节点。
      • 右旋：用于调整左倾的红链接。以红色右链接的父节点为中心，将其左子树提升为新的根，原节点变为新根的右子节点，新根的原右子节点变为原节点的新左子节点。
      • 什么时候旋转：
        1. 左黑右红左旋转：右子节点是红色，左子节点是黑色，则左旋转。
        2. 连续左红右旋转：左子节点是红色，且其左子节点也是红色，则右旋转。
        3. 左右皆红则变色：左右子节点都是红色，则进行颜色转换。
    2. 插入操作：
      • 新插入的节点默认为红色。
      • 可能违反红黑树的性质，需要通过旋转和重新着色来修复。
      • 时间复杂度：O(log⁡n)，修复操作最多需要树的高度的旋转和着色操作。
    3. 删除操作：
      • 删除后可能会导致红黑树的性质被破坏，导致某条路径的黑色节点数量减少，通常会涉及修复操作（双重黑色处理）。
      • 修复时可能需要多次旋转和重新着色。
        • 兄弟节点染色调整：将兄弟节点变红或变黑以重新平衡。
        • 旋转操作：必要时调整树结构。
      • 时间复杂度：O(log⁡n)。
    4. 查找操作：
      • 类似二叉搜索树的查找，根据键值递归或迭代。
      • 时间复杂度：O(log⁡n)。

  • 时间复杂度：

    1. 高度分析：红黑树的性质保证树的高度 h 与节点个数 n 满足： h≤2log⁡(n+1) 因此，树的高度是对数级别。
    2. 操作的时间复杂度：
      • 查找：最多需要遍历树的高度，即 O(log⁡n)。
      • 插入：插入后需要从插入点向上修复树的性质，修复涉及的旋转和重新着色次数也是 O(log⁡n)。
      • 删除：与插入类似，删除后可能需要从删除点向上修复，时间复杂度为 O(log⁡n)。
    3. 空间复杂度：
      • 红黑树存储每个节点的颜色，空间复杂度为 O(n)。
      • 若递归实现查找、插入或删除，递归栈的空间复杂度为 O(log⁡n)。

  • 代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    class RedBlackTree {
        private static final boolean RED = true;
        private static final boolean BLACK = false;

        static class Node {
            int key;
            boolean color;
            Node left, right, parent;

            Node(int key) {
                this.key = key;
                this.color = RED;
            }
        }

        private Node root;

        // 左旋转
        private void leftRotate(Node x) {
            Node y = x.right;
            x.right = y.left;
            if (y.left != null) y.left.parent = x;

            y.parent = x.parent;
            if (x.parent == null) root = y;
            else if (x == x.parent.left) x.parent.left = y;
            else x.parent.right = y;

            y.left = x;
            x.parent = y;
        }

        // 右旋转
        private void rightRotate(Node x) {
            Node y = x.left;
            x.left = y.right;
            if (y.right != null) y.right.parent = x;

            y.parent = x.parent;
            if (x.parent == null) root = y;
            else if (x == x.parent.right) x.parent.right = y;
            else x.parent.left = y;

            y.right = x;
            x.parent = y;
        }

        // 插入修复
        private void insertFixup(Node z) {
            while (z.parent != null && z.parent.color == RED) {
                if (z.parent == z.parent.parent.left) {
                    Node y = z.parent.parent.right;
                    if (y != null && y.color == RED) {
                        z.parent.color = BLACK;
                        y.color = BLACK;
                        z.parent.parent.color = RED;
                        z = z.parent.parent;
                    } else {
                        if (z == z.parent.right) {
                            z = z.parent;
                            leftRotate(z);
                        }
                        z.parent.color = BLACK;
                        z.parent.parent.color = RED;
                        rightRotate(z.parent.parent);
                    }
                } else {
                    Node y = z.parent.parent.left;
                    if (y != null && y.color == RED) {
                        z.parent.color = BLACK;
                        y.color = BLACK;
                        z.parent.parent.color = RED;
                        z = z.parent.parent;
                    } else {
                        if (z == z.parent.left) {
                            z = z.parent;
                            rightRotate(z);
                        }
                        z.parent.color = BLACK;
                        z.parent.parent.color = RED;
                        leftRotate(z.parent.parent);
                    }
                }
            }
            root.color = BLACK;
        }

        public void insert(int key) {
            Node z = new Node(key);
            Node y = null;
            Node x = root;

            while (x != null) {
                y = x;
                if (z.key < x.key) x = x.left;
                else x = x.right;
            }

            z.parent = y;
            if (y == null) root = z;
            else if (z.key < y.key) y.left = z;
            else y.right = z;

            insertFixup(z);
        }

        public void inorder(Node node) {
            if (node != null) {
                inorder(node.left);
                System.out.print(node.key + " ");
                inorder(node.right);
            }
        }

        public void display() {
            inorder(root);
            System.out.println();
        }

        public static void main(String[] args) {
            RedBlackTree rbt = new RedBlackTree();
            rbt.insert(10);
            rbt.insert(20);
            rbt.insert(15);
            rbt.insert(25);
            rbt.insert(30);

            rbt.display();  // In-order traversal: 10 15 20 25 30
        }
    }

问：红黑树和AVL树？

  • 红黑树本质是2-3树，属于平衡二叉树，其2-结点等价于普通二叉树结点，3-结点本质是非平衡性的缓存。红黑树本质是用空间换时间，通过牺牲平衡性减少了插入/删除时的旋转次数，所以查询会略慢于AVL树，但综合各种情况来看性能会略优于AVL树。红黑树非严格平衡二叉树，因为其用红黑链+二叉树来实现3-结点的设计，导致无法严格控制所有空链接到根结点距离相等。
  • AVL树即平衡二叉查找树，要求是一个空树或左右子树高度差不能超过1，子树仍是平衡二叉树。AVL是其中一种平衡二叉树实现AVL树查询效率会略高于红黑树。AVL树被应用于Windows进程地址空间管理。

综合：

  • AVL是严格的平衡树，因此在增加或者删除节点的时候，根据不同情况，旋转的次数比红黑树要多；
  • 红黑树是用非严格的平衡来换取增删节点时候旋转次数的降低开销；
  • 红黑树综合性能略高，AVL查询速度略快。所以简单说，查询多选择AVL树，查询更新次数差不多选红黑树。
  • AVL树顺序插入和删除时有20%左右的性能优势，红黑树随机操作15%左右优势，现实应用当然一般都是随机情况，所以红黑树得到了更广泛的应用索引为B+树 Hashmap为红黑树。

红黑树和AVL树是两种常见的 自平衡二叉搜索树，它们在设计和用途上有明显的区别。以下是它们的对比分析：

特性 红黑树 AVL树
平衡性质 相对宽松的平衡：基于“黑高平衡”，红色节点可以连续。 严格的平衡：每个节点的左右子树高度差最多为 1。
主要用途 适用于插入和删除操作较多的场景（如操作系统内核）。 适用于查找操作频繁、插入删除较少的场景。
平衡调整 通过红黑规则（颜色变化和旋转）进行调整。 通过旋转操作进行调整（单旋或双旋）。
平衡修复代价 调整代价较低，插入或删除时最多旋转 O(log⁡n)次。 调整代价较高，插入或删除可能触发多次旋转。
树高 树高为 O(log⁡n)，但比 AVL 树稍高。 树高为 O(log⁡n)，通常低于红黑树。
查找 O(log⁡n)，树高稍高，性能略低。 O(log⁡n)，更严格平衡，性能更高。
插入 O(log⁡n)，调整代价较低。 O(log⁡n)，可能触发多次旋转，代价较高。
删除 O(log⁡n)，调整代价较低。 O(log⁡n)，代价较高，需严格维持平衡。
常用场景 适合增删改操作频繁的场景，例如：1. STL 中的 std::map 和 std::set。2. Java 中的 TreeMap 和 TreeSet。3. 数据库索引（例如 MongoDB）。 适合查找操作频繁、插入删除较少的场景，例如：1. 数据库的少量动态索引。2. 只读或写入操作较少的结构化数据。
代码复杂度 实现相对复杂，需要处理颜色规则。 实现稍复杂，需要维护严格平衡条件。
调整代价 红黑规则放松，调整代价低。 严格平衡，调整代价高。
优点 1. 插入和删除性能更优（旋转和调整较少）。2. 应对高频动态操作时效率更高。 1. 查找效率更高（更低的树高）。2. 适合频繁查找操作的场景。
缺点 1. 查找效率比 AVL 稍低。 1. 插入和删除成本高（严格平衡条件）。

选择建议

  • 红黑树：

    • 如果应用中 增删操作频繁，如实时动态更新的数据结构，选择红黑树更为合适。
    • 实际应用中，许多主流库如 TreeMap、TreeSet、std::map 等都采用红黑树。

  • AVL树：

    • 如果应用中 查找操作占主导，并且插入和删除较少，选择 AVL 树能提供更高的查找效率。

  • 适合索引查找等需要严格高效的读操作场景。

  • 红黑树：平衡稍松，适合频繁动态操作。
  • AVL树：平衡严格，适合频繁查找操作。

两者的核心权衡在于平衡效率与动态操作的代价，因此根据具体场景需求选择更合适的树结构。

问：为啥redis zset使用跳跃链表而不用红黑树实现？

Redis 的 zset（有序集合）是通过 跳跃表（skiplist） 和 哈希表 结合实现的，而不是使用红黑树。

1. 跳跃表的简单性与效率

  • 实现简单：跳跃表的代码实现比红黑树简单很多。红黑树的插入、删除和调整操作需要维护复杂的平衡规则，而跳跃表只需要通过随机化索引来保持结构的平均效率。
  • 时间复杂度相似：跳跃表的时间复杂度为 O(log⁡n，与红黑树相同。Redis 追求极高的性能，跳跃表能够提供足够快的操作效率，而无需引入复杂的红黑树实现。在并发环境下红黑树在插入和删除时需要rebalance，性能不如跳表。

2. 跳跃表更适合范围查询

  • 跳跃表支持高效的 范围查询，例如 ZRANGEBYSCORE 和 ZRANGEBYLEX 操作。由于跳跃表是基于链表的结构，查找起点后，范围内的元素可以通过链表的线性遍历快速获取，逻辑简单高效。
  • 红黑树虽然也支持范围查询，但由于它是一种树结构，范围内的遍历需要进行中序遍历，指针跳转复杂，效率相对较低。

3. 内存使用与存储结构

  • 跳跃表的节点通过链表方式组织，存储紧凑，内存布局相对连续。相比之下，红黑树的节点是分散的，指针管理较多，可能带来额外的内存开销。
  • 跳跃表还允许通过随机级别分布来平衡性能和内存使用，使得结构在大规模数据场景下更加灵活。

4. 易于实现持久化和数据转储

  • 跳跃表的结构非常适合 Redis 的 RDB 持久化 和 AOF（Append Only File）日志。其数据结构序列化简单，可以直接遍历链表输出所有节点。
  • 红黑树由于复杂的平衡逻辑和多指针结构，实现序列化和反序列化的成本更高。

5. 工程上的灵活性与扩展性

  • 跳跃表易于实现水平扩展，例如通过增加跳表层数来支持更大的数据规模。
  • Redis 的 zset 不仅使用跳跃表存储数据，还结合了哈希表，用于快速定位特定元素。这种结合方式在跳跃表中实现相对简单，但在红黑树中实现则需要更复杂的设计。

总结

特性 跳跃表 红黑树
时间复杂度 O(log⁡n) O(log⁡n)
实现复杂度 简单，基于链表 较复杂，需维护平衡规则
范围查询效率 高效，链表结构遍历性能优越 较低，需通过中序遍历实现
内存开销 内存利用率较高 节点分散，指针管理开销大
序列化与持久化 简单，链表遍历即可 复杂，需要特殊处理指针和结构

Redis 选择跳跃表，是在满足性能需求的基础上，追求实现简单、代码可维护性高的结果。在 Redis 的使用场景中，跳跃表的性能完全足够，并且更适合于 Redis 的整体架构和设计理念。

问：跳表和二叉树的区别？

  • 跳表维持结构平衡的成本较低，完全依靠随机；二叉树则在多次插入删除后，通过再平衡操作来重新调整结构平衡。
  • 跳表非树结构，分索引节点和底层链表节点，索引节点只有右边和下边两条索引，链表节点则只有下个节点索引，而二叉树节点则有左右子结点。

补充：Redis通过跳跃表的优化实现Sorted-set维护有序集合，而关系型数据库则采用B+树。

跳表和二叉树都是用于快速查找、插入和删除的数据结构，但它们的实现方式和适用场景不同。以下是两者的详细对比：

1. 数据结构特点

特性 跳表 二叉树
结构 多层链表，每层是有序链表 树状结构，每个节点最多有两个子节点
节点关系 水平和垂直连接，通过随机化生成多层索引 父节点和子节点关系由规则决定
存储方式 基于链表，节点之间通过指针连接 树状结构，节点之间通过父子指针连接
平衡维护 通过随机化索引层级近似实现平衡 自平衡二叉树（如红黑树、AVL树）严格保持平衡

2. 操作复杂度

操作 跳表（时间复杂度） 二叉树（时间复杂度）
查找 O(log⁡n) O(log⁡n)（平衡树）
插入 O(log⁡n) O(log⁡n)（平衡树）
删除 O(log⁡n) O(log⁡n)（平衡树）

如果二叉树未平衡（普通二叉搜索树），时间复杂度可能退化为 O(n)，但跳表通过随机化索引避免了这种退化。

3. 实现复杂度

特性 跳表 二叉树
实现复杂度 简单，基于链表和随机化层级 较复杂，需维护平衡性（红黑树、AVL树）
插入/删除调整 只需更新少量索引 需调整树的平衡性
代码维护难度 较低，逻辑相对直观 较高，需理解平衡算法和旋转操作

4. 空间复杂度

特性 跳表 二叉树
节点存储 每个节点有多个前进指针，约占 2n2n 指针空间 每个节点占用两个指针空间
总空间复杂度 O(n)O(n) O(n)O(n)

5. 范围查询效率

特性 跳表 二叉树
范围查询 高效，链表结构便于线性遍历 中序遍历效率相对较低，需频繁跳转指针

6. 应用场景

特性 跳表 二叉树
适合场景 - Redis 中实现 zset- 内存操作较多 - 数据库索引（如 B+ 树）- 高性能查询
缺点 不适合磁盘存储，受限于随机化效果 实现复杂，尤其是维护平衡逻辑

7. 总结

维度 跳表 二叉树
优点 - 简单高效，易实现- 范围查询性能更好 - 更严格的平衡性，最坏情况下性能稳定
缺点 - 查找性能依赖随机化- 空间开销略大 - 实现复杂，操作需要维护平衡
适用场景 - 内存中快速查找、范围查询（如 Redis） - 更高性能的查询，如数据库索引

两者各有优劣，跳表更适合于简单实现、快速开发和轻量级场景，而二叉树更适合需要严格平衡、高性能和复杂查询的场景。

问：讲下跳表怎么实现的?哈夫曼编码是怎么回事？

1. 跳跃表的实现

跳跃表是一种 基于链表的多层结构，通过在链表中引入多级索引，实现快速查找、插入和删除操作。它是 Redis zset 的核心数据结构之一。

跳跃表的基本构造

  1. 层级结构：

    • 跳跃表是一个多层链表，每一层是一个有序链表。

    • 上层链表比较稀疏，越下层越密集。最底层（Level 0）包含所有元素，表示完整的数据链表。

    • 每一层的节点是下一层节点的子集，高层节点通过随机化生成。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      ->               31
      ->2->            31
      ->2->            31->    96
      ->2->10->15->16->31->71->96
      第一层：
      	从起点出发，沿着第一层的指针移动。
      	遇到的第一个元素是2，小于16，继续移动。
      	遇到的下一个元素是31，大于16，此时停下来，不能再沿着第一层移动了。
      第二层：
      	回到元素2的位置，沿着第二层的指针移动。
      	遇到的第一个元素是10，小于16，继续移动。
      	遇到的下一个元素是15，小于16，继续移动。
      	遇到的下一个元素是16，等于16，查找成功！
  2. 节点结构：每个节点包含：
    • 数据值data。
    • 多个前进指针（forward pointers），指向不同层的下一个节点。right指针和down指针。
    • （可选）一些额外的字段（如跨度、排名等）。
  3. 构造规则：节点的层数通过随机算法决定（如抛硬币法），使得节点层数的分布呈指数递减。先插入底层链表，再分别投掷硬币判断是否向上层链表插入。每向上一层预期节点会减少一半，高度预期为logn。

跳跃表的核心操作

  1. 查找操作：
    • 从顶层开始，沿着当前层的链表查找目标节点。
    • 如果目标值大于当前节点值，则向右移动；否则向下移动到下一层。
    • 时间复杂度为 O(log⁡n)。
  2. 插入操作：
    • 查找插入位置后，将新节点插入到所有相关层级。
    • 新节点的层数通过随机化决定。
    • 时间复杂度为 O(log⁡n)。
  3. 删除操作：
    • 查找到目标节点后，将其从上到下所有相关层级中移除。
    • 时间复杂度为 O(log⁡n)。

2. 哈夫曼编码

  • 哈夫曼编码是一种基于 贪心算法 的最优前缀编码，用于无损数据压缩。它通过频率最小化的方式，为更常用的字符分配更短的编码，从而实现高效压缩。

基本步骤

  1. 统计字符频率：对于每个字符，统计其在数据中的出现频率。
  2. 构建优先队列：将每个字符及其频率作为一个叶子节点放入优先队列（最小堆）。
  3. 构建哈夫曼树：
    • 每次从队列中取出两个最小频率的节点，合并成一个新节点，新节点的频率等于两个子节点的频率之和。
    • 将新节点放回队列，重复直到队列中只剩一个节点（根节点）。
  4. 生成编码：
    • 从根节点到叶节点的路径决定每个字符的编码。
    • 通常向左为 0，向右为 1。

时间复杂度

  • 构建哈夫曼树：O(nlog⁡n)，主要由优先队列操作决定。
  • 编码生成：O(n)。

问：什么是B树？什么是B+树？二者的区别？

  1. 什么是 B 树？

    • B树是一种自平衡的多路搜索树，保证数据的有序，一个节点拥有两个以上的子节点，实现高效的查找、插入和删除操作。

    • 特点：

      1. 自平衡：每次的插入、删除操作，若破坏树的平衡性，则会调整至平衡。

      2. 多路搜索树：

        • 平衡二叉树通常是指查找路径只有两种，而B树则不仅仅二叉，所以也叫平衡多路查找树。
        • 每个节点可以有多个子节点，通常节点的最大子节点数用阶数 m 表示。
        • 对于一个 m 阶 B 树，每个节点最多有 m−1 个关键字，最多 m 个子节点。
        • 除根节点外，所有节点至少包含 Math.ceil(⌈m/2⌉) - 1 （向上取整）个子节点。
        • B 树通过限制阶数 m，保证树的高度尽可能低，从而提高搜索、插入、删除的效率。

      3. 节点有序：每个节点内的关键字（keys）按递增顺序存储，子节点分布在关键字的两侧。如下图，父节点键值为[10,20]，表示：

        • 左子节点的所有键值 <10。
        • 中间子节点的所有键值 ≥10 且 <20。
        • 右子节点的所有键值 ≥20。
        1
        2
        3
              [10, 20]
             /   |   \
        [1,5]  [12,15] [25,30]

      4. 操作高效：查找、插入和删除的时间复杂度均为 O(log⁡n) 。

    • 节点结构：B树的节点包含关键字（keys）和子节点指针，每个节点可以有多个子节点（最多m个）。

    • 数据存储： B树的每个节点同时存储数据，叶子节点包含了数据的完整信息（实际是指针）。

    • 查找方式： 通过节点间的指针进行逐层搜索，每一层的节点可以包含多个关键字，提高了查找效率。

    • 应用场景： 适用于内存空间有限，需要高效进行插入、删除和查找操作的场景，例如文件系统的索引结构。2-3树、红黑树都是常见的B树。

    • B树相比平衡二叉树：B树在每个节点所包含的内容更多，在应用到数据库中的时候，充分利用了磁盘块的原理（磁盘数据存储是采用块的形式存储的，每个块的大小为4K，每次IO进行数据读取时，同一个磁盘块的数据可以一次性读取出来）把节点大小限制和充分使用在磁盘块大小范围。所以树的节点能包含更多的内容后，树的层级比原来的二叉树少了，就可以减少数据查找的次数和复杂度。

    • B树相对于B+树的优点：如果经常访问的数据离根节点很近，而B树的非叶子节点本身存有关键字其数据的地址，所以这种数据检索的时候会要比B+树快。

    • 自平衡操作：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      初始状态，阶数 m=3，高度 h=3：
        节点最多存储 m − 1 = 2个键值。
        节点最少存储 Math.ceil(⌈m/2⌉) - 1 = 1个键值。
        最多有m = 3和子节点。
        
                     [15]
                  /       \
            [5, 10]      [20, 25]
           /   |   \      /   |   \
         [1]  [6]  [12] [17] [22] [27]
      插入键值 13：不破坏平衡
                       [15]
                  /            \
            [5, 10]           [20, 25]
           /   |    \         /   |   \
         [1]  [6]  [12, 13] [17] [22] [27]
      插入键值 14：破坏平衡，[12, 13, 14] ，触发分裂，分裂为 [12] 和 [14]，中间值 13 上升到父节点 [5,10]超过上限，需进一步分裂为 [5] 和 [13]，中间值 10 上升到根节点：
                        [10, 15]
                   /         |         \
                [5]       [13]       [20, 25]
              /   \       /   \       /   |   \
            [1]   [6]  [12] [14]  [17] [22] [27]

  2. 什么是 B+ 树？

    • B+树是B树的一种变体，增加了链表结构，键值的拷贝被存储在内部结点，键值和记录则存储在叶子结点，叶子结点间相互链接组成一组有序链表。更适合范围查询和顺序访问。

    • 特点：

      1. 平衡性：B+树的每个节点都保持平衡，即每个节点的子节点数量相同或相差1。能够保持数据稳定有序，其插入与修改拥有较稳定的对数时间复杂度。
      2. 多路查找：B+树的每个节点可以存储多个键值对，因此查找效率较高。
      3. 顺序访问：B+树的叶子节点通过指针连接在一起，形成一个有序链表，因此可以支持顺序访问。
      4. 所有数据存储在叶子节点：
        • 非叶子节点只存储索引（关键字），不存储具体数据。
        • 叶子节点包含所有关键字及数据，并通过链表相连。
      5. 叶子节点链表：叶子节点按关键字递增顺序排列，通过指针相互连接，便于范围查询。
      6. 非叶子节点只起索引作用：非叶子节点用于导航，使B+树每个非叶子结点所能保存的关键字数大大增加，查找效率更高。

    • 节点结构： B+树的内部节点/非叶子节点只包含关键字和子节点指针，叶子节点存储数据，只存储关键字和指向数据的指针。

      1
      2
      3
      4
      5
             [10, 20]
            /   |   \
        [1,5] [12,15] [25,30]
         |       |       |
      [1,5]-->[12,15]-->[25,30]

    • 数据存储： 数据只存储在叶子节点上，叶子节点之间通过两个指针分别指向前一个和后一个节点链接成双向链表，便于范围查询。

    • 查找方式： 通过内部节点的关键字进行搜索，查找到叶子节点后再进行线性查找，提高了范围查询的效率。

    • 应用场景： 适用于需要频繁进行范围查询和顺序遍历的场景，例如数据库中的索引结构。

    • B+ 树元素自底向上插入，这与二叉树恰好相反。

    • B+树叶子结点保存了父结点的所有关键字记录的指针，所有数据地址必须到叶子结点才能获取到，所以每次数据查询的次数都相同。B+树叶子结点的关键字从小到大有序排列，左边结尾数据都会保存右边节点开始数据的指针。

    • 查找操作：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      假设B+树结构为：
                  [1、10、20]
                  /
             [1、4、7]  ......
              /    | 
      [1、2、3] [4、5、6]  ......
      一条SQL查询id为5的数据，首先于根节点进行比较，在1和10之间，所以到1连接的第二层节点
      再比较后发现位于4和7之间，所以到4连接的叶子节点，最终找到索引值为5的数据。
      总共经历3个节点，也就是3个I/O操作。

      所以B+树相比于 B 树和二叉树来说，最大的优势在于查询效率很高，因为即使在数据量很大的情况，查询一个数据的磁盘 I/O 依然维持在 3-4次。

      如果查询条件不是ID，比如走普通索引，则要先查普通索引的B+树找到id，再查主键索引的B+树。若普通索引字段能全部在叶子节点查到，即索引覆盖，无需再查一个B+树。

    • 自平衡操作：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      高度为 3 的 B+ 树（阶数 3）：
       内部节点存储键值 m−1=2。
       叶子节点存储键值 m−1=2，并通过链表连接。
       根节点至少有 2 个子节点。
       所有键值存储在叶子节点中。
       
                    [15]
                /           \
            [10]             [20]
           /    \           /    \
       [5, 7] [10, 12] [17, 19] [22, 25]
      叶子链表: [5, 7] -> [10, 12] -> [17, 19] -> [22, 25]

      插入 键值 13：[10, 12，13]分裂，中间值12上升 
                     [15]
                  /       \
            [10, 12]       [20]
           /   |    \      /   \
       [5, 7] [10] [13] [17, 19] [22, 25]

  3. B 树与 B+ 树的区别？B树和B+树都是左小右大。

    • B+树的层级更少：相较于B树，B+树的每个非叶子节点存储的关键字数更多（即阶数M更大），树的层级更少所以查询数据更快；
    • B+树查询速度更稳定：B+所有关键字数据地址都存在叶子节点上，所以每次查找的次数都相同所以查询速度要比B树更稳定;
    • B+树天然具备排序功能：B+树所有的叶子节点数据构成了一个有序链表，在查询大小区间的数据时候更方便，数据紧密性很高，缓存的命中率也会比B树高。
    • B+树全节点遍历更快：B+树遍历整棵树只需要遍历所有的叶子节点即可，而不需要像B树一样需要对每一层进行遍历，这有利于数据库做全表扫描。
    特性 B 树 B+ 树
    数据存储位置 数据存储在所有节点中 数据只存储在叶子节点中
    索引节点 非叶子节点存储数据和索引 非叶子节点只存储索引，不存储数据
    叶子节点链表 无叶子节点链表 叶子节点通过链表连接，便于范围查询
    查询效率 查询需要访问到目标数据节点 查询效率更高，因为索引更小
    范围查询效率 需通过树结构遍历多个节点完成范围查询 通过叶子节点链表直接完成范围查询
    树的高度 较高 较低，因为索引更小
    适用场景 插入、删除频繁的场景 查询频繁且范围查询需求高的场景

    4. 使用场景对比

    1. B 树：
      • 用于需要频繁插入、删除以及随机访问的场景。
      • 例如：存储数据较小的嵌入式系统。
    2. B+ 树：
      • 用于数据库索引和文件系统索引（如 MySQL 的 InnoDB）。
      • 因为支持顺序访问和范围查询，性能更优。

    B+ 树是实际应用中更常见的选择，尤其是在数据库系统中，因其支持高效的顺序访问和范围查询。

问：数据库索引为什么不选用跳表，而是B+树

1. B+树对磁盘存储更友好

(1) 数据的块式组织

  • 数据库的底层是基于磁盘的存储，而磁盘的读取是以块（通常为 4KB 或 8KB）为单位的。
  • B+树将节点设计为多路平衡树，每个节点可以包含大量的键值，能够有效利用磁盘块，将多次访问压缩到少量的磁盘 I/O 操作。

(2) 顺序访问的高效性

  • B+树的叶子节点以链表方式连接，所有数据都存储在叶子节点中，支持顺序扫描。对范围查询特别高效。
  • 跳表虽然支持顺序访问，但它没有磁盘块的分组概念，不如 B+树对磁盘友好。

2. B+树的多层次索引

  • B+树是多路平衡树（比如一个 B+树的阶数是 m，每个节点最多有 m-1 个键值和 m 个子节点）。
  • 这种结构使得树的高度较低，即便是百万级或千万级数据，B+树的高度也通常在 3-5 层，查询时只需要访问少量节点。
  • 跳表的高度增长较快：
    • 跳表的高度与数据规模相关性较高，数据量增大时，跳表的层数也会增多，导致查询效率降低。
    • 虽然跳表理论上支持 O(log n) 的查找，但其索引层的组织效率在大规模数据中不如 B+树。

3. B+树支持范围查询更高效

  • B+树所有数据都存储在叶子节点，并且叶子节点通过链表连接：
    • 对于范围查询，B+树从某个叶子节点开始，只需沿着链表顺序扫描即可，无需回到上层节点。
  • 跳表支持范围查询，但效率较低：
    • 跳表需要通过每一层的指针跳跃找到范围的起始节点，然后在底层链表中遍历范围，额外的指针跳跃开销较高。

4. B+树的查找效率更稳定

  • B+树的每个节点都保持平衡，任何一次查找都需要从根节点到叶子节点，路径长度一致，性能稳定。
  • 跳表的性能依赖于概率：
    • 跳表通过随机化方式生成索引层，虽然均摊复杂度为 O(log n)，但在某些情况下（例如生成的索引层高度偏低），性能可能不稳定。

5. 实现的复杂度

  • B+树的实现虽然复杂，但其结构更适合数据库存储需求，已经有成熟的实现和优化。
  • 跳表的实现相对简单，但在复杂的数据库场景下，维护索引层的随机化效果、优化磁盘 I/O 等方面略显不足。

总结

特性 B+树 跳表
磁盘友好性 节点按磁盘块设计，能减少磁盘 I/O 无磁盘块优化
范围查询 高效，链表顺序遍历 支持但效率较低
性能稳定性 查找路径稳定，所有路径长度相同 依赖随机化，可能性能波动
实现复杂度 复杂，但已成熟优化 简单，但缺乏针对磁盘优化

由于 B+树更适合大规模数据存储和查询，能够更好地适应数据库索引需求，因此它成为数据库索引的首选，而跳表更适合轻量级应用场景（例如 Redis）。

问：图的数据结构？遍历方法？

图（Graph）是一种非线性数据结构，由顶点（Vertices）和边（Edges）组成。它广泛用于社交网络、路径查找、计算机网络等领域。

1. 基本概念

(1) 顶点（Vertex / Node）

  • 图中的基本单位，通常用 V 表示顶点集合。
  • 例如：V = {A, B, C, D, E} 表示 5 个顶点。

(2) 边（Edge）

  • 顶点之间的连接，通常用 E 表示边的集合。
  • 例如：E = {(A, B), (B, C), (C, D), (D, E)}。

(3) 图的类型

根据边的方向性和权重，图可以分为：

  1. 无向图（Undirected Graph）
    • 边是无方向的，(A, B) 表示 A 和 B 互相连接。
    • 例如：A —— B —— C
  2. 有向图（Directed Graph, Digraph）
    • 边是有方向的，(A → B) 表示 A 指向 B。
    • 例如：A → B → C
  3. 加权图（Weighted Graph）
    • 每条边都有一个权重（Weight），表示连接的成本。
    • 例如：A ——(2)—— B ——(3)—— C

2.存储方式

图可以用邻接矩阵和邻接表两种方式存储。

(1) 邻接矩阵（Adjacency Matrix）

  • 定义：使用一个 N × N 的矩阵 graph[i][j] 存储顶点 i 到 j 之间的边。

  • 特点：

    • 适用于 稠密图（边较多）。
    • 查询是否有边的时间复杂度为 O(1)。
    • **空间复杂度：O(N²)**（存储 N² 个元素）。

  • 示例（无向图）：

    1
    2
    3
    4
    5
    6
    7
    顶点集合 V = {A, B, C, D}

         A  B  C  D
      A  0  1  0  1
      B  1  0  1  1
      C  0  1  0  1
      D  1  1  1  0

  • 代码实现（Java）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class GraphMatrix {
        private int[][] adjMatrix;
        private int size;

        public GraphMatrix(int size) {
            this.size = size;
            adjMatrix = new int[size][size];
        }

        public void addEdge(int u, int v) {
            adjMatrix[u][v] = 1; // 无向图
            adjMatrix[v][u] = 1;
        }

        public boolean hasEdge(int u, int v) {
            return adjMatrix[u][v] == 1;
        }
    }

(2) 邻接表（Adjacency List）

  • 定义：使用链表/列表存储每个顶点的邻接顶点集合。

  • 特点：

    • 适用于 稀疏图（边较少）。
    • 存储仅存在的边，节省空间。
    • **空间复杂度：O(N + E)**（存储 N 个顶点和 E 条边）。

  • 示例（无向图）：

    1
    2
    3
    4
    A: B → D
    B: A → C → D
    C: B → D
    D: A → B → C

  • 代码实现（Java）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import java.util.*;

    class GraphList {
        private Map<Integer, List<Integer>> adjList;

        public GraphList() {
            adjList = new HashMap<>();
        }

        public void addEdge(int u, int v) {
            adjList.putIfAbsent(u, new ArrayList<>());
            adjList.putIfAbsent(v, new ArrayList<>());
            adjList.get(u).add(v);
            adjList.get(v).add(u); // 无向图
        }

        public List<Integer> getNeighbors(int v) {
            return adjList.getOrDefault(v, new ArrayList<>());
        }
    }

3. 图的遍历

(1) 深度优先搜索（DFS）

  • 思路：

    1. 选择一个起点，从当前节点继续深入访问，直到无法前进，再回溯。
    2. 适用于 连通分量搜索、路径搜索、拓扑排序。

  • 代码（递归实现）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    class GraphDFS {
        private Map<Integer, List<Integer>> adjList = new HashMap<>();
        private Set<Integer> visited = new HashSet<>();

        public void addEdge(int u, int v) {
            adjList.putIfAbsent(u, new ArrayList<>());
            adjList.putIfAbsent(v, new ArrayList<>());
            adjList.get(u).add(v);
            adjList.get(v).add(u);
        }

        public void dfs(int node) {
            if (visited.contains(node)) return;
            System.out.print(node + " ");
            visited.add(node);
            for (int neighbor : adjList.getOrDefault(node, new ArrayList<>())) {
                dfs(neighbor);
            }
        }
    }

(2) 广度优先搜索（BFS）

  • 思路：

    1. 选择一个起点，先访问当前层的所有节点，再逐层深入。
    2. 适用于 最短路径搜索（如 Dijkstra 算法）。

  • 代码（使用队列实现）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    import java.util.*;

    class GraphBFS {
        private Map<Integer, List<Integer>> adjList = new HashMap<>();

        public void addEdge(int u, int v) {
            adjList.putIfAbsent(u, new ArrayList<>());
            adjList.putIfAbsent(v, new ArrayList<>());
            adjList.get(u).add(v);
            adjList.get(v).add(u);
        }

        public void bfs(int start) {
            Queue<Integer> queue = new LinkedList<>();
            Set<Integer> visited = new HashSet<>();

            queue.offer(start);
            visited.add(start);

            while (!queue.isEmpty()) {
                int node = queue.poll();
                System.out.print(node + " ");
                for (int neighbor : adjList.getOrDefault(node, new ArrayList<>())) {
                    if (!visited.contains(neighbor)) {
                        queue.offer(neighbor);
                        visited.add(neighbor);
                    }
                }
            }
        }
    }

4. 图的应用

应用 描述 算法
最短路径 计算最短路径 Dijkstra, Bellman-Ford, Floyd-Warshall
最小生成树 计算连接所有点的最小代价 Prim, Kruskal
拓扑排序 依赖关系排序（如课程安排） Kahn, DFS
连通分量 计算图中连通的部分 DFS, BFS
二分图判定 判断是否可二分 DFS

总结

存储方式 邻接矩阵 邻接表
适用情况 稠密图（边多） 稀疏图（边少）
查询 O(1) ✅ ❌（遍历链表 O(N)）
存储空间 O(N²) ❌（占用空间大） ✅（占用空间小）
遍历方式 DFS、BFS DFS、BFS

如果是稀疏图，建议使用邻接表，如果是稠密图，建议使用邻接矩阵。🚀

问：动态规划？

动态规划（Dynamic Programming, DP）是一种递归 + 记忆化的优化思想，适用于最优子结构和重叠子问题的场景，广泛用于路径规划、子序列问题、背包问题等。

1. 适用场景

一个问题可以用动态规划解决，通常满足：

  1. 最优子结构（Optimal Substructure）
    • 一个问题的最优解可以由其子问题的最优解推导得出。
    • 示例：最短路径问题，当前最短路径 = 子路径的最短路径 + 当前节点。
  2. 重叠子问题（Overlapping Subproblems）
    • 相同的子问题会被重复计算，可通过记忆化存储（缓存）优化。
    • 示例：斐波那契数列，F(n) = F(n-1) + F(n-2)，F(n-1) 和 F(n-2) 会多次计算。

2. 解题步骤

(1) 确定状态

  • 定义 dp[i] 代表问题的某个子问题的解。
  • 例如，斐波那契 dp[i] 代表第 i 个斐波那契数。

(2) 确定状态转移方程

  • 通过最优子结构，找到状态的递推关系。
  • 例如，dp[i] = dp[i-1] + dp[i-2]（斐波那契数列）。

(3) 确定初始值

  • 例如，dp[0] = 0, dp[1] = 1。

(4) 计算顺序

  • 一般从小到大计算，保证 dp[i] 计算时 dp[i-1] 已经计算好。

3. 经典动态规划问题

(1) 斐波那契数列

问题描述：求第 n 个斐波那契数，F(n) = F(n-1) + F(n-2)，其中 F(0) = 0, F(1) = 1。

递归（指数时间）

1
2
3
4
5
6
public class FibonacciRecursive {
    public int fib(int n) {
        if (n <= 1) return n;
        return fib(n - 1) + fib(n - 2);
    }
}

缺点：大量重复计算，时间复杂度 O(2^n)。

记忆化搜索（自顶向下，O(n)）

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.HashMap;

public class FibonacciMemo {
    private HashMap<Integer, Integer> memo = new HashMap<>();

    public int fib(int n) {
        if (n <= 1) return n;
        if (memo.containsKey(n)) return memo.get(n);
        int result = fib(n - 1) + fib(n - 2);
        memo.put(n, result);
        return result;
    }
}

动态规划（自底向上，O(n)）

1
2
3
4
5
6
7
8
9
10
11
12
public class FibonacciDP {
    public int fib(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];
    }
}

优化空间复杂度（O(1)）

1
2
3
4
5
6
7
8
9
10
11
12
public class FibonacciOptimized {
    public int fib(int n) {
        if (n <= 1) return n;
        int a = 0, b = 1, temp;
        for (int i = 2; i <= n; i++) {
            temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }
}

(2) 最长上升子序列（LIS）

问题描述：给定数组 nums，找到最长递增子序列的长度。
示例：

1
2
3
输入: nums = [10, 9, 2, 5, 3, 7, 101, 18]
输出: 4
最长上升子序列是 [2, 3, 7, 101]

动态规划解法（O(n²)）

  • dp[i] 代表以 nums[i] 结尾的最长上升子序列的长度。

  • 状态转移方程：

    1
    2
    以i结尾的队列最长上升子序列长度 = 小于i的各个位置最长上升子序列长度+1
    dp[i] = max(dp[j] + 1) for all j < i where nums[j] < nums[i]

  • 代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LIS {
    public int lengthOfLIS(int[] nums) {
        if (nums.length == 0) return 0;
        int n = nums.length, maxLIS = 1;
        int[] dp = new int[n];
        Arrays.fill(dp, 1); // 初始每个元素自身算 LIS 长度为 1
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLIS = Math.max(maxLIS, dp[i]);
        }
        return maxLIS;
    }
}

(3) 0/1 背包问题

问题描述：给定 N 件物品，每件物品有重量 w[i] 和价值 v[i]，一个容量为 W 的背包，求最大总价值。

动态规划解法

  • dp[i][j] 表示前 i 件物品，容量 j 时的最大价值。

  • 状态转移方程：

    1
    2
    前i件物品容量为j时最大价值 = 前i-1件物品容量-当前物品重量，与当前物品价值的最大值。
    dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])
    • dp[i-1][j]：不选当前物品 i，价值不变。
    • dp[i-1][j-w[i]] + v[i]：选当前物品 i，容量减少 w[i]，价值增加 v[i]。

  • 代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Knapsack {
    /**
     * 0/1 背包问题 - 动态规划解法
     * @param W 背包的最大容量
     * @param weights 物品的重量数组
     * @param values 物品的价值数组
     * @return 能装入背包的最大总价值
     */
    public int knapsack(int W, int[] weights, int[] values) {
        int n = weights.length; // 物品数量
        
        // dp[i][j] 表示前 i 个物品在容量 j 时的最大价值
        int[][] dp = new int[n + 1][W + 1];
        
        // 遍历每个物品（i 从 1 开始，因为 0 号行代表不选任何物品）
        for (int i = 1; i <= n; i++) {
            // 遍历背包容量（j 从 1 开始，因为容量为 0 时最大价值只能是 0）
            for (int j = 1; j <= W; j++) {
                if (weights[i - 1] <= j) { // 当前物品能放入背包
                    // 选择：不放入当前物品 vs. 放入当前物品并更新价值
                    dp[i][j] = Math.max(
                        dp[i - 1][j], // 不选当前物品，价值与前 i-1 件物品相同
                        dp[i - 1][j - weights[i - 1]] + values[i - 1] // 选当前物品
                    );
                } else {
                    // 不能放入当前物品，则价值等于前 i-1 件物品的最优解
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        
        // 返回能装入背包的最大总价值
        return dp[n][W];
    }
}

总结

问题 状态定义 状态转移方程
斐波那契数列 dp[i] 代表第 i 个数 dp[i] = dp[i-1] + dp[i-2]
最长上升子序列 dp[i] 以 nums[i] 结尾的 LIS 长度 dp[i] = max(dp[j] + 1) if nums[j] < nums[i]
0/1 背包 dp[i][j] 前 i 个物品，容量 j 时最大价值 dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])

动态规划的核心是 状态定义 + 状态转移方程，掌握后可以解决大多数最优化问题！🚀

问：哈夫曼编码？

哈夫曼编码（Huffman Coding）是一种最优前缀编码（Optimal Prefix Code）算法，广泛用于数据压缩。它基于贪心策略，以最少的比特数表示出现频率高的字符，从而减少编码长度。

主要特点：

  • 前缀编码：不会出现某个字符的编码是另一个字符编码的前缀，保证唯一可解。
  • 最优性：对于给定字符集的定长编码，哈夫曼编码是最优的。
  • 可变长编码：不同字符可能使用不同长度的编码，高频字符编码短，低频字符编码长。

哈夫曼编码的核心是哈夫曼树，构造方式如下：

  1. 统计字符频率：计算每个字符出现的次数。
  2. 构造优先队列：按频率升序排序，将每个字符视为独立的节点。
  3. 合并节点：
    • 取出频率最小的两个节点，构造一个新节点，权值为两者之和。
    • 让新节点成为这两个节点的父节点，并放回优先队列。
    • 重复此过程，直到队列中仅剩一个节点（即根节点）。
  4. 编码生成：
    • 左子树路径标记为 0，右子树路径标记为 1。
    • 遍历树生成字符对应的二进制编码。

示例

输入： AABBCD
字符频率统计：

1
A: 2, B: 2, C: 1, D: 1

哈夫曼树构造过程：

  1. 选取最小频率的两个字符 C(1) 和 D(1)，合并为 CD(2)。
  2. 选取 CD(2) 和 B(2)，合并为 BCD(4)。
  3. 选取 BCD(4) 和 A(2)，合并为 root(6)。
1
2
3
4
5
6
7
   (6)
  /   \
A(2) (4)
    /   \
  B(2) (2)
     /   \
   C(1)  D(1)

生成编码表：

1
2
3
4
A: 0
B: 10
C: 110
D: 111

编码结果：

1
AABBCD → 001010110111

Java 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.util.*;

class HuffmanNode {
    int freq;
    char ch;
    HuffmanNode left, right;

    HuffmanNode(char ch, int freq) {
        this.ch = ch;
        this.freq = freq;
    }
}

// 哈夫曼编码主类
public class HuffmanCoding {
    public static Map<Character, String> buildHuffmanCode(Map<Character, Integer> freqMap) {
        PriorityQueue<HuffmanNode> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a.freq));

        // 创建初始节点
        for (var entry : freqMap.entrySet()) {
            pq.offer(new HuffmanNode(entry.getKey(), entry.getValue()));
        }

        // 构建哈夫曼树
        while (pq.size() > 1) {
            HuffmanNode left = pq.poll();
            HuffmanNode right = pq.poll();
            HuffmanNode parent = new HuffmanNode('\0', left.freq + right.freq);
            parent.left = left;
            parent.right = right;
            pq.offer(parent);
        }

        // 生成哈夫曼编码表
        Map<Character, String> huffmanCode = new HashMap<>();
        generateHuffmanCode(pq.poll(), "", huffmanCode);
        return huffmanCode;
    }

    private static void generateHuffmanCode(HuffmanNode node, String code, Map<Character, String> huffmanCode) {
        if (node == null) return;
        if (node.ch != '\0') {
            huffmanCode.put(node.ch, code);
        }
        generateHuffmanCode(node.left, code + "0", huffmanCode);
        generateHuffmanCode(node.right, code + "1", huffmanCode);
    }

    public static void main(String[] args) {
        String text = "AABBCD";
        
        // 统计字符频率
        Map<Character, Integer> freqMap = new HashMap<>();
        for (char c : text.toCharArray()) {
            freqMap.put(c, freqMap.getOrDefault(c, 0) + 1);
        }

        // 生成哈夫曼编码
        Map<Character, String> huffmanCode = buildHuffmanCode(freqMap);

        // 输出编码
        System.out.println("Huffman Codes: " + huffmanCode);

        // 编码文本
        StringBuilder encodedText = new StringBuilder();
        for (char c : text.toCharArray()) {
            encodedText.append(huffmanCode.get(c));
        }
        System.out.println("Encoded Text: " + encodedText);
    }
}

输出示例：

1
2
Huffman Codes: {A=0, B=10, C=110, D=111}
Encoded Text: 001010110111

复杂度分析

  • 构造哈夫曼树（最小堆构建 + 合并节点） → O(n log n)
  • 编码生成（DFS 遍历树） → O(n)
  • 总时间复杂度 → O(n log n)

哈夫曼编码的应用

  • 文件压缩（ZIP、JPEG、MP3）
    • 通过减少冗余实现压缩，减少存储空间。
  • 数据传输优化（Huffman-based TCP/IP Header Compression）
    • 在网络数据传输中减少数据大小，提高效率。
  • 图像 & 语音压缩（JPEG、MP3、G.711 编码）
    • JPEG 压缩中使用变长编码降低存储成本。

总结

  • 哈夫曼编码利用贪心策略，每次选择最小频率字符合并。
  • 生成的编码是前缀编码，不会有二义性。
  • 复杂度 O(n log n)，适用于大规模数据压缩。

哈夫曼编码在现代计算机科学和数据压缩中扮演着重要角色，是贪心算法的经典应用之一。

问：贪心算法？

贪心算法（Greedy Algorithm）是一种在每一步都做出局部最优选择，最终希望能得到全局最优解的算法。它不回溯或修改之前的决定，而是直接走到问题的终点。

核心思想：

  • 贪心选择性（Greedy Choice Property）：每一步都做出当前最优选择，最终能得到全局最优解。
  • 最优子结构（Optimal Substructure）：问题的最优解可以由子问题的最优解合并而成。

贪心算法通常适用于 求最优解 或 近似最优解 的问题，常见应用包括 最小生成树、Huffman 编码、区间调度、活动选择等。

常见应用

（1）区间选择问题

问题描述： 给定 n 个区间 [start, end]，求最多能选择多少个互不重叠的区间？

贪心策略：每次选择结束时间最早的区间，然后排除与其重叠的区间。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Arrays;

public class IntervalScheduling {
    public static int maxNonOverlappingIntervals(int[][] intervals) {
        if (intervals.length == 0) return 0;
        
        // 按照结束时间排序
        Arrays.sort(intervals, (a, b) -> a[1] - b[1]);

        int count = 0, end = Integer.MIN_VALUE;
        for (int[] interval : intervals) {
            if (interval[0] >= end) { // 当前区间的起点 >= 上一个区间的终点，说明不重叠
                count++;
                end = interval[1]; // 更新已选区间的结束时间
            }
        }
        return count;
    }

    public static void main(String[] args) {
        int[][] intervals = {{1, 3}, {2, 4}, {3, 5}, {6, 8}};
        System.out.println(maxNonOverlappingIntervals(intervals)); // 输出 2
    }
}

复杂度分析：

  • 排序：O(n log n)
  • 遍历：O(n)
  • 总复杂度：O(n log n)

（2）Huffman 编码

问题描述： 给定一组字符及其出现频率，构造最优二进制编码，使总编码长度最短。

贪心策略：

  • 频率越小的字符越应该用更长的编码。
  • 采用哈夫曼树（Huffman Tree）：每次选取两个最小频率的节点合并。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.PriorityQueue;

class HuffmanNode {
    int freq;
    HuffmanNode left, right;
    HuffmanNode(int freq) { this.freq = freq; }
}

// 哈夫曼编码
public class HuffmanCoding {
    public static int huffman(int[] freq) {
        PriorityQueue<HuffmanNode> pq = new PriorityQueue<>((a, b) -> a.freq - b.freq);
        
        // 初始化最小堆
        for (int f : freq) pq.offer(new HuffmanNode(f));

        // 构造哈夫曼树
        while (pq.size() > 1) {
            HuffmanNode left = pq.poll(), right = pq.poll();
            HuffmanNode newNode = new HuffmanNode(left.freq + right.freq);
            newNode.left = left;
            newNode.right = right;
            pq.offer(newNode);
        }
        
        return pq.poll().freq; // 最终根节点的频率即最优编码长度
    }

    public static void main(String[] args) {
        int[] freq = {5, 9, 12, 13, 16, 45}; // 字符出现频率
        System.out.println(huffman(freq)); // 输出 97（最优编码总长度）
    }
}

复杂度分析：

  • 构造最小堆：O(n log n)
  • 取最小值 & 插入堆：O(n log n)
  • 总复杂度：O(n log n)

（3）最小生成树（MST）：Prim / Kruskal 算法

问题描述： 给定一个连通无向图，求最小生成树，使得所有顶点连通且边权总和最小。

贪心策略：

  • Prim 算法：从任意顶点开始，每次选取当前能到达的最短边，不断扩展树。
  • Kruskal 算法：按照边权排序，然后用并查集（Union-Find）判断是否形成环，贪心地选取最小边。

Kruskal 代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.*;

class Edge {
    int u, v, weight;
    Edge(int u, int v, int weight) { this.u = u; this.v = v; this.weight = weight; }
}

public class KruskalMST {
    static int[] parent;

    static int find(int x) {
        return parent[x] == x ? x : (parent[x] = find(parent[x])); // 路径压缩
    }

    static void union(int x, int y) {
        parent[find(x)] = find(y);
    }

    public static int kruskal(int n, List<Edge> edges) {
        Collections.sort(edges, (a, b) -> a.weight - b.weight);
        parent = new int[n];
        for (int i = 0; i < n; i++) parent[i] = i;

        int mstWeight = 0, count = 0;
        for (Edge edge : edges) {
            if (find(edge.u) != find(edge.v)) { // 不连通则加入 MST
                mstWeight += edge.weight;
                union(edge.u, edge.v);
                count++;
                if (count == n - 1) break; // 选够 n-1 条边
            }
        }
        return mstWeight;
    }

    public static void main(String[] args) {
        List<Edge> edges = Arrays.asList(
            new Edge(0, 1, 1), new Edge(0, 2, 2), new Edge(1, 2, 3),
            new Edge(1, 3, 4), new Edge(2, 3, 5)
        );
        System.out.println(kruskal(4, edges)); // 输出 7
    }
}

复杂度分析：

  • 边排序：O(E log E)
  • 并查集查找+合并：O(E log V)
  • 总复杂度：O(E log E)

贪心算法 vs. 动态规划

比较 贪心算法 动态规划
解决问题类型 最优化问题（局部最优） 复杂优化问题（全局最优）
是否回溯 不回溯 可能回溯
适用条件 贪心选择性 + 最优子结构 最优子结构 + 重叠子问题
常见应用 Huffman 编码、最小生成树、区间调度 背包问题、最长子序列、编辑距离

总结

  • 贪心算法 适用于局部最优能推出全局最优的情况，例如最小生成树、Huffman 编码、区间调度等。
  • 需要满足贪心选择性 和 最优子结构。
  • 若问题存在后效性（即当前决策影响未来决策），可能要用 动态规划 而非贪心。

如果某问题不能保证局部最优能带来全局最优，就需要使用 动态规划 或 回溯 进行更精确的计算。

三. 基础算法题

1. 数组和字符串

  • 给定一个整数数组，找出和为目标值的两个数（Two Sum 问题）。
  • 判断一个字符串是否是回文字符串。
  • 实现字符串的反转（不用内置函数）。
  • 找到一个数组中连续子数组的最大和（Kadane’s Algorithm）。
  • 给定两个字符串，判断是否是字母异位词（Anagram）。

请依次给出如下基础算法的解析、代码、时间和空间复杂度：

Two Sum 问题：给定一个整数数组，找出和为目标值的两个数

解析：

  • 暴力法：通过双重循环遍历所有可能的数对，时间复杂度为 O(n^2)。
  • 哈希表法：通过哈希表存储已访问的元素，减少查找时间。时间复杂度为 O(n)。

代码实现（哈希表法）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.HashMap;
import java.util.Map;

public class TwoSum {
    public int[] twoSum(int[] nums, int target) {
        // 哈希表，键存数，值存坐标
        Map<Integer, Integer> map = new HashMap<>();
        // 遍历数组，若与目标的差取不到，则将当前数放入Map，若取到则分别返回二者坐标
        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[]{-1, -1}; // 如果没有找到
    }

    public static void main(String[] args) {
        TwoSum solution = new TwoSum();
        int[] nums = {2, 7, 11, 15};
        int[] result = solution.twoSum(nums, 9);
        System.out.println("Indices: [" + result[0] + ", " + result[1] + "]");
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，我们只遍历数组一次。
  • 空间复杂度：O(n)，需要额外的空间来存储哈希表。

回文：判断一个字符串是否是回文字符串

回文字符串是指正着读和反着读都一样的字符串。可以通过双指针法来判断：

  • 一个指针从字符串的头开始，另一个指针从尾部开始，逐个比较字符，直到两个指针相遇。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Palindrome {
    public boolean isPalindrome(String s) {
        int left = 0, right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    public static void main(String[] args) {
        Palindrome solution = new Palindrome();
        System.out.println(solution.isPalindrome("racecar")); // true
        System.out.println(solution.isPalindrome("hello"));   // false
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，我们只需一次遍历字符串。
  • 空间复杂度：O(1)，只使用常数空间。

字符反转：实现字符串的反转（不用内置函数）

可以通过双指针法来反转字符串，一个指针从头开始，另一个从尾部开始，交换两个指针指向的字符直到两个指针相遇。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ReverseString {
    public String reverseString(String s) {
        char[] chars = s.toCharArray();
        int left = 0, right = chars.length - 1;
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        return new String(chars);
    }

    public static void main(String[] args) {
        ReverseString solution = new ReverseString();
        System.out.println(solution.reverseString("hello")); // "olleh"
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历整个字符串。
  • 空间复杂度：O(n)，需要转换为字符数组。

动态规划：找到一个数组中连续子数组的最大和（Kadane’s Algorithm）

Kadane’s Algorithm 用于解决最大子数组和问题。通过动态规划的方法，可以在一次遍历中找到最大和：

  • 维护一个当前子数组和 currentSum 和最大子数组和 maxSum。
  • 每一步，currentSum 为当前元素和之前的子数组和之和。如果小于当前元素，则从当前元素开始新子数组。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MaxSubArray {
    public int maxSubArray(int[] nums) {
        int currentSum = nums[0];
        int maxSum = nums[0];
        for (int i = 1; i < nums.length; i++) {
            currentSum = Math.max(nums[i], currentSum + nums[i]);
            maxSum = Math.max(maxSum, currentSum);
        }
        return maxSum;
    }

    public static void main(String[] args) {
        MaxSubArray solution = new MaxSubArray();
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        System.out.println(solution.maxSubArray(nums)); // 6
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，只需要遍历数组一次。
  • 空间复杂度：O(1)，只使用常数空间。

给定两个字符串，判断是否是字母异位词（Anagram）

字母异位词是指两个字符串中的字符相同且出现的次数相同。常见的做法是排序法或计数法：

  • 排序法：将两个字符串排序后比较是否相同，时间复杂度 O(nlog⁡n)。
  • 计数法：通过计数每个字符出现的次数，时间复杂度 O(n)。

代码实现（计数法）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Arrays;

public class Anagram {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;
        
        int[] count = new int[26]; // 假设是小写字母
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;
            count[t.charAt(i) - 'a']--;
        }
        
        for (int c : count) {
            if (c != 0) return false;
        }
        
        return true;
    }

    public static void main(String[] args) {
        Anagram solution = new Anagram();
        System.out.println(solution.isAnagram("anagram", "nagaram")); // true
        System.out.println(solution.isAnagram("rat", "car"));         // false
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，遍历字符串两次。
  • 空间复杂度：O(1)，使用一个长度为 26 的数组，空间复杂度是常数。

2. 排序与搜索

实现快速排序和归并排序

快速排序（Quick Sort）

解析：

快速排序是一种分治算法，它通过选择一个“基准”元素，将数组分为左右两部分，左边的元素比基准小，右边的元素比基准大，然后递归排序两部分。

  • 最坏情况：当每次选取的基准元素都接近数组的最大或最小值时，时间复杂度为 O(n^2)。
  • 最好和平均情况：O(nlog⁡n)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class QuickSort {
    public void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 对当前子数组进行分区操作，并返回基准元素的索引
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    /**
     * 分区方法：以 arr[high] 为基准，将小于等于基准的元素移到基准左侧，
     *          大于基准的元素移到右侧，并返回基准最终所在的索引。
     */
    private int partition(int[] arr, int low, int high) {
        // 选择当前子数组的最后一个元素作为基准
        int pivot = arr[high];
        // i 表示已处理区域的最后一个位置，初始值为 low - 1
        int i = low - 1;
        for (int j = low; j < high; j++) {
            // 如果当前元素小于等于基准，右移处理区域指针，并交换当前元素到已处理区域的末尾
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        // 把 pivot 放到正确的位置，即已处理区域的末尾
        swap(arr, i + 1, high);
        return i + 1;
    }

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

    public static void main(String[] args) {
        QuickSort solution = new QuickSort();
        int[] arr = {10, 7, 8, 9, 1, 5};
        solution.quickSort(arr, 0, arr.length - 1);
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

时间和空间复杂度：

  • 时间复杂度：最坏情况 O(n^2)，最佳和平均情况 O(nlog⁡n)，分区总是均匀分割数组。
  • 空间复杂度：O(log⁡n)，因为递归栈的最大深度为 O(log⁡n)。

归并排序（Merge Sort）

解析：

归并排序是一种稳定的排序算法，也是分治算法。通过递归地将数组分为两部分，分别排序，然后合并两个已排序的部分。

  • 时间复杂度：无论最坏、最好还是平均情况都是 O(nlog⁡n)O(n \log n)。
  • 空间复杂度：O(n)O(n)，需要额外的空间用于合并。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class MergeSort {
    public void mergeSort(int[] arr) {
        if (arr.length < 2) return;
        int mid = arr.length / 2;
        // 分别复制左右半部分的子数组
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);

        // 分别对左右半部分递归调用 mergeSort 进行排序
        mergeSort(left);
        mergeSort(right);

        // 合并已排序的左右两部分
        merge(arr, left, right);
    }

    private void merge(int[] arr, int[] left, int[] right) {
        // 分别指向 left、right 和 arr 的当前索引
        int i = 0, j = 0, k = 0;
        // 比较 left 和 right 中的元素，将较小的放入 arr
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }
        // 将左右数组剩余的元素放入 arr（如果有剩余）
        while (i < left.length) arr[k++] = left[i++];
        while (j < right.length) arr[k++] = right[j++];
    }

    public static void main(String[] args) {
        MergeSort solution = new MergeSort();
        int[] arr = {10, 7, 8, 9, 1, 5};
        solution.mergeSort(arr);
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

时间和空间复杂度：

  • 时间复杂度：O(nlog⁡n)，无论最坏、最好还是平均情况。
  • 空间复杂度：O(n)，需要额外的数组存储分割的部分。
归并排序 快速排序
算法思想 先将数组分成两部分，分别排序后再合并。 选取一个基准值（pivot），将数组划分为比基准值小和大的两部分，然后递归地对两部分排序。
时间复杂度 时间复杂度稳定，无论数据分布如何，都是 O(nlogn) 平均时间复杂度为 O(nlog⁡n)，但在最坏情况下（比如数组已排序，且每次都选到最小或最大的基准值），退化为 O(n2)。 可通过随机选取基准值或三数取中法降低最坏情况发生的概率。
空间复杂度 需要额外的数组来存储合并的结果，空间复杂度为 O(n) 不需要额外数组，空间复杂度为 O(log⁡n)（递归栈的深度）
稳定性 稳定排序，两个相等的元素在排序后相对顺序不会改变 不稳定排序，交换操作可能导致相等元素的相对顺序改变
  • 归并排序：
    • 对数组 [8, 4, 3, 7, 6, 5, 2, 1]：
      • 分割为 [8, 4, 3, 7] 和 [6, 5, 2, 1]。
      • 再分割为 [8, 4], [3, 7], [6, 5], [2, 1]。
      • 合并为 [4, 8], [3, 7], [5, 6], [1, 2]。
      • 最终合并为 [1, 2, 3, 4, 5, 6, 7, 8]。
  • 快速排序：
    • 对数组 [8, 4, 3, 7, 6, 5, 2, 1] ：
      • 选择基准值 1，划分为 [ ] 和 [8, 4, 3, 7, 6, 5, 2]。
      • 递归处理右半部分，基准值 2，划分为 [ ] 和 [8, 4, 3, 7, 6, 5]。
      • 重复直至排序完成。

在一个旋转排序数组中查找目标值（如 [4, 5, 6, 7, 0, 1, 2]）

  • 解析：旋转排序数组是一个经过旋转的升序数组，目标是找到该数组中的目标值。我们可以使用修改版的二分查找来完成此任务。通过判断中间元素与左右元素的关系来确定目标值在哪个部分。
  • 如：原始有序数组: [1, 2, 3, 4, 5, 6, 7] 旋转后（以索引 3 为分界点）: [4, 5, 6, 7, 1, 2, 3]

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class SearchRotatedArray {
    public int search(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 (nums[left] <= nums[mid]) {
                // 左侧有序，若目标值位于左侧，则更新右边界为左侧队尾
                if (nums[left] <= target && target < nums[mid]) {
                    right = mid - 1;
                } else {
                // 左侧有序，目标值位于右侧，则更新左边界为右侧队首
                    left = mid + 1;
                }
            } else {
                // 左侧无序，说明右侧有序
                if (nums[mid] < target && target <= nums[right]) {
                // 右侧有序，若目标值位于右侧，则更新左边界为右侧队首
                    left = mid + 1;
                } else {
                // 右侧有序，且目标值位于左侧，则更新右边界为左侧队尾
                    right = mid - 1;
                }
            }
        }
        return -1; // 如果目标值不存在
    }

    public static void main(String[] args) {
        SearchRotatedArray solution = new SearchRotatedArray();
        int[] nums = {4, 5, 6, 7, 0, 1, 2};
        System.out.println(solution.search(nums, 0)); // 4
        System.out.println(solution.search(nums, 3)); // -1
    }
}

时间和空间复杂度：

  • 时间复杂度：O(log⁡n)，由于使用了二分查找。
  • 空间复杂度：O(1)，只使用常数空间。

找出第 K 个最大的元素

解析： 可以使用快排的思想（快速选择）来找到第 K 个最大的元素。或者使用最小堆来找。

代码实现（快速选择）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.Arrays;

public class KthLargestElement {
    public int findKthLargest(int[] nums, int k) {
        return quickSelect(nums, 0, nums.length - 1, nums.length - k);
    }

    private int quickSelect(int[] nums, int left, int right, int index) {
        if (left == right) return nums[left];

        int pivotIndex = partition(nums, left, right);
        if (pivotIndex == index) return nums[pivotIndex];
        else if (pivotIndex < index) return quickSelect(nums, pivotIndex + 1, right, index);
        else return quickSelect(nums, left, pivotIndex - 1, index);
    }

    private int partition(int[] nums, int left, int right) {
        int pivot = nums[right];
        int i = left;
        for (int j = left; j < right; j++) {
            if (nums[j] <= pivot) {
                swap(nums, i, j);
                i++;
            }
        }
        swap(nums, i, right);
        return i;
    }

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

    public static void main(String[] args) {
        KthLargestElement solution = new KthLargestElement();
        int[] nums = {3, 2, 1, 5, 6, 4};
        System.out.println(solution.findKthLargest(nums, 2)); // 5
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)O(n) 平均情况下，最坏情况下 O(n2)O(n^2)。
  • 空间复杂度：O(1)O(1)，只使用常数空间。

中级算法题

1. 链表

反转一个单向链表

解析：我们可以通过三指针法来反转链表，逐一改变节点的指向。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class ReverseLinkedList {
    public ListNode reverseList(ListNode head) {
        // 前一个指针
        ListNode prev = null;
        // 当前指针
        ListNode curr = head;
        // 循环链表
        while (curr != null) {
            // 下一个指针，先指向当前节点的下一个节点
            ListNode nextTemp = curr.next;
            // 将当前节点本来指向nextTemp的指针，改为指向前一个节点prev
            curr.next = prev;
            // 分别将prev和curr后移一位处理下一个节点
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }

    public static void main(String[] args) {
        // 创建链表 [1, 2, 3]
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);

        ReverseLinkedList solution = new ReverseLinkedList();
        ListNode reversedHead = solution.reverseList(head);
        while (reversedHead != null) {
            System.out.print(reversedHead.val + " ");
            reversedHead = reversedHead.next;
        }
    }
}

class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历一次链表。

  • 空间复杂度：O(1)，只使用常数空间。

判断一个链表是否有环，并找到环的起始点

解析：可以使用快慢指针的方法。通过快指针和慢指针相遇来判断链表是否有环，再通过另一个指针找出环的起始点。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class LinkedListCycle {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head, fast = head;
        // 循环遍历链表，慢指针移动一步，快指针移动两步，若二者相遇，说明有环
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                // 有环，则让ptr从头追赶slow指针，相遇则为环的起点
                ListNode ptr = head;
                while (ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }
        return null; // 无环
    }

    public static void main(String[] args) {
        // 创建链表并构造环
        ListNode head = new ListNode(3);
        head.next = new ListNode(2);
        head.next.next = new ListNode(0);
        head.next.next.next = new ListNode(-4);
        head.next.next.next.next = head.next; // 环

        LinkedListCycle solution = new LinkedListCycle();
        ListNode cycleStart = solution.detectCycle(head);
        if (cycleStart != null) {
            System.out.println("Cycle starts at node with value: " + cycleStart.val);
        } else {
            System.out.println("No cycle.");
        }
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，快慢指针遍历链表。
  • 空间复杂度：O(1)，只使用常数空间。

合并两个排序的链表

解析：我们可以使用双指针方法，逐个比较两个链表的节点，并将较小的节点连接到结果链表中。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class MergeTwoSortedLists {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                current.next = l1;
                l1 = l1.next;
            } else {
                current.next = l2;
                l2 = l2.next;
            }
            current = current.next;
        }
        if (l1 != null) current.next = l1;
        if (l2 != null) current.next = l2;

        return dummy.next;
    }

    public static void main(String[] args) {
        // 创建两个排序链表
        ListNode l1 = new ListNode(1);
        l1.next = new ListNode(2);
        l1.next.next = new ListNode(4);

        ListNode l2 = new ListNode(1);
        l2.next = new ListNode(3);
        l2.next.next = new ListNode(4);

        MergeTwoSortedLists solution = new MergeTwoSortedLists();
        ListNode mergedList = solution.mergeTwoLists(l1, l2);
        while (mergedList != null) {
            System.out.print(mergedList.val + " ");
            mergedList = mergedList.next;
        }
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n + m)，需要遍历两个链表。
  • 空间复杂度：O(1)，不需要额外的空间。

给定两个链表，找到它们的交点

解析：可以使用双指针法，让两个指针从头开始走，当指针到达链表尾部时，跳到另一个链表的头部。最终指针会在交点相遇。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class IntersectionOfLinkedLists {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) return null;
        ListNode pA = headA;
        ListNode pB = headB;
        while (pA != pB) {
            pA = (pA == null) ? headB : pA.next;
            pB = (pB == null) ? headA : pB.next;
        }
        return pA;
    }

    public static void main(String[] args) {
        // 创建两个链表并设置交点
        ListNode headA = new ListNode(4);
        headA.next = new ListNode(1);
        headA.next.next = new ListNode(8);
        headA.next.next.next = new ListNode(4);
        headA.next.next.next.next = new ListNode(5);

        ListNode headB = new ListNode(5);
        headB.next = new ListNode(0);
        headB.next.next = new ListNode(1);
        headB.next.next.next = headA.next.next; // 交点

        IntersectionOfLinkedLists solution = new IntersectionOfLinkedLists();
        ListNode intersection = solution.getIntersectionNode(headA, headB);
        System.out.println(intersection != null ? intersection.val : "No intersection");
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n + m)，需要遍历两个链表。
  • 空间复杂度：O(1)，只使用常数空间。

2. 树与图

好的，下面是每个算法的解析、代码实现及时间和空间复杂度分析。

实现二叉树的前序、中序、后序遍历（递归与非递归）

前序遍历（递归和非递归）

解析：

  • 递归方式：前序遍历是先访问根节点，再遍历左子树，最后遍历右子树。
  • 非递归方式：使用栈来模拟递归的过程。

代码实现（递归方式）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class PreOrderTraversal {
    public void preOrder(TreeNode root) {
        if (root == null) return;
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        PreOrderTraversal solution = new PreOrderTraversal();
        solution.preOrder(root);  // Output: 1 2 3
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int val) {
        this.val = val;
    }
}

代码实现（非递归方式）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Stack;

public class PreOrderTraversalNonRecursive {
    public void preOrder(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.val + " ");
            if (node.right != null) stack.push(node.right);
            if (node.left != null) stack.push(node.left);
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        PreOrderTraversalNonRecursive solution = new PreOrderTraversalNonRecursive();
        solution.preOrder(root);  // Output: 1 2 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历树的每个节点。
  • 空间复杂度：O(n)，最坏情况下栈的大小为树的高度，递归时栈深度为 O(h)。

中序遍历（递归和非递归）

解析：

  • 递归方式：先遍历左子树，访问根节点，再遍历右子树。
  • 非递归方式：使用栈来模拟递归的过程，栈保存访问的节点。

代码实现（递归方式）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class InOrderTraversal {
    public void inOrder(TreeNode root) {
        if (root == null) return;
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        InOrderTraversal solution = new InOrderTraversal();
        solution.inOrder(root);  // Output: 2 1 3
    }
}

代码实现（非递归方式）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Stack;

public class InOrderTraversalNonRecursive {
    public void inOrder(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode current = root;
        while (current != null || !stack.isEmpty()) {
            while (current != null) {
                stack.push(current);
                current = current.left;
            }
            current = stack.pop();
            System.out.print(current.val + " ");
            current = current.right;
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        InOrderTraversalNonRecursive solution = new InOrderTraversalNonRecursive();
        solution.inOrder(root);  // Output: 2 1 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历树的每个节点。
  • 空间复杂度：O(n)，栈存储节点，最坏情况下为树的高度。

后序遍历（递归和非递归）

解析：

  • 递归方式：先遍历左子树，再遍历右子树，最后访问根节点。
  • 非递归方式：使用两个栈或一个栈和一个指针来模拟递归。

代码实现（递归方式）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class PostOrderTraversal {
    public void postOrder(TreeNode root) {
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        PostOrderTraversal solution = new PostOrderTraversal();
        solution.postOrder(root);  // Output: 2 3 1
    }
}

代码实现（非递归方式）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Stack;

public class PostOrderTraversalNonRecursive {
    public void postOrder(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.push(root);
        while (!stack1.isEmpty()) {
            TreeNode node = stack1.pop();
            stack2.push(node);
            if (node.left != null) stack1.push(node.left);
            if (node.right != null) stack1.push(node.right);
        }
        while (!stack2.isEmpty()) {
            System.out.print(stack2.pop().val + " ");
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        PostOrderTraversalNonRecursive solution = new PostOrderTraversalNonRecursive();
        solution.postOrder(root);  // Output: 2 3 1
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历树的每个节点。
  • 空间复杂度：O(n)，使用栈来存储节点。

求二叉树的最大深度

解析：最大深度是从根节点到最远叶节点的路径长度。可以使用深度优先搜索（DFS）递归遍历树来计算最大深度。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MaxDepth {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        MaxDepth solution = new MaxDepth();
        System.out.println(solution.maxDepth(root));  // Output: 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)O(n)，需要遍历树的每个节点。
  • 空间复杂度：O(h)O(h)，递归栈的空间复杂度，hh 是树的高度。

验证一个二叉树是否是二叉搜索树（BST）

解析：二叉搜索树的特性是：左子树所有节点的值小于根节点的值，右子树所有节点的值大于根节点的值，且左右子树分别也是二叉搜索树。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ValidateBST {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    private boolean isValidBST(TreeNode root, long min, long max) {
        if (root == null) return true;
        if (root.val <= min || root.val >= max) return false;
        return isValidBST(root.left, min, root.val) && isValidBST(root.right, root.val, max);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(2);
        root.left = new TreeNode(1);
        root.right = new TreeNode(3);
        ValidateBST solution = new ValidateBST();
        System.out.println(solution.isValidBST(root));  // Output: true
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历树的每个节点。
  • 空间复杂度：(O(h))，递归栈的空间复杂度，h 是树的高度。

找到二叉树中两个节点的最近公共祖先（LCA）

解析：使用递归，遍历树。若当前节点是两个节点之一，则返回当前节点。如果左右子树分别包含这两个节点，则当前节点为它们的最近公共祖先。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LowestCommonAncestor {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left != null && right != null) return root;
        return left != null ? left : right;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(3);
        root.left = new TreeNode(5);
        root.right = new TreeNode(1);
        root.left.left = new TreeNode(6);
        root.left.right = new TreeNode(2);
        root.right.left = new TreeNode(0);
        root.right.right = new TreeNode(8);
        LowestCommonAncestor solution = new LowestCommonAncestor();
        System.out.println(solution.lowestCommonAncestor(root, root.left, root.right).val);  // Output: 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)O，需要遍历树的每个节点。
  • 空间复杂度：O(h)，递归栈的空间复杂度，h 是树的高度。

实现图的深度优先搜索（DFS）和广度优先搜索（BFS）

深度优先搜索（DFS）

解析：深度优先搜索通过递归或栈来遍历图，探索每一个节点的深度。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.*;

public class DFS {
    public void dfs(Map<Integer, List<Integer>> graph, int start) {
        Set<Integer> visited = new HashSet<>();
        dfsHelper(graph, start, visited);
    }

    private void dfsHelper(Map<Integer, List<Integer>> graph, int node, Set<Integer> visited) {
        if (visited.contains(node)) return;
        visited.add(node);
        System.out.print(node + " ");
        for (int neighbor : graph.get(node)) {
            dfsHelper(graph, neighbor, visited);
        }
    }

    public static void main(String[] args) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        graph.put(1, Arrays.asList(2, 3));
        graph.put(2, Arrays.asList(1, 4, 5));
        graph.put(3, Arrays.asList(1));
        graph.put(4, Arrays.asList(2));
        graph.put(5, Arrays.asList(2));
        DFS solution = new DFS();
        solution.dfs(graph, 1);  // Output: 1 2 4 5 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(V + E)，其中 V 是图的顶点数，E 是图的边数。
  • 空间复杂度：O(V)，需要存储访问过的节点。

广度优先搜索（BFS）

解析：广度优先搜索从起始节点开始，探索所有邻居节点，再逐层向外扩展。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.*;

public class BFS {
    public void bfs(Map<Integer, List<Integer>> graph, int start) {
        Set<Integer> visited = new HashSet<>();
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(start);
        visited.add(start);
        while (!queue.isEmpty()) {
            int node = queue.poll();
            System.out.print(node + " ");
            for (int neighbor : graph.get(node)) {
                if (!visited.contains(neighbor)) {
                    visited.add(neighbor);
                    queue.offer(neighbor);
                }
            }
        }
    }

    public static void main(String[] args) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        graph.put(1, Arrays.asList(2, 3));
        graph.put(2, Arrays.asList(1, 4, 5));
        graph.put(3, Arrays.asList(1));
        graph.put(4, Arrays.asList(2));
        graph.put(5, Arrays.asList(2));
        BFS solution = new BFS();
        solution.bfs(graph, 1);  // Output: 1 2 3 4 5
    }
}

时间和空间复杂度：

  • 时间复杂度：O(V + E)，其中 V 是图的顶点数，E 是图的边数。
  • 空间复杂度：O(V)，需要存储访问过的节点。

判断一个图是否是连通图

解析：一个图是连通图，当且仅当图中从任意一个顶点出发，都能到达其他顶点。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.*;

public class IsConnectedGraph {
    public boolean isConnected(Map<Integer, List<Integer>> graph, int n) {
        Set<Integer> visited = new HashSet<>();
        dfs(graph, 1, visited);
        return visited.size() == n;
    }

    private void dfs(Map<Integer, List<Integer>> graph, int node, Set<Integer> visited) {
        visited.add(node);
        for (int neighbor : graph.get(node)) {
            if (!visited.contains(neighbor)) {
                dfs(graph, neighbor, visited);
            }
        }
    }

    public static void main(String[] args) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        graph.put(1, Arrays.asList(2, 3));
        graph.put(2, Arrays.asList(1, 4, 5));
        graph.put(3, Arrays.asList(1));
        graph.put(4, Arrays.asList(2));
        graph.put(5, Arrays.asList(2));
        IsConnectedGraph solution = new IsConnectedGraph();
        System.out.println(solution.isConnected(graph, 5));  // Output: true
    }
}

时间和空间复杂度：

  • 时间复杂度：O(V + E)，需要遍历图的每个节点和边。
  • 空间复杂度：O(V)，需要存储访问过的节点。

3. 动态规划

爬楼梯问题（Fibonacci 数列变种）

解析：爬楼梯问题是一个经典的动态规划问题。假设你每次可以爬 1 步或 2 步，那么问题变成了计算爬到第 n 阶楼梯的不同方式数。这个问题实际上是 Fibonacci 数列的变种，结果是 dp[i]=dp[i−1]+dp[i−2]，即到达第 i 阶的方法数是到达第 i−1 阶和第 i−2 阶的方法数之和。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ClimbingStairs {
    public int climbStairs(int n) {
        if (n <= 2) return n;
        int first = 1, second = 2;
        for (int i = 3; i <= n; i++) {
            int temp = first + second;
            first = second;
            second = temp;
        }
        return second;
    }

    public static void main(String[] args) {
        ClimbingStairs solution = new ClimbingStairs();
        System.out.println(solution.climbStairs(5));  // Output: 8
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)，需要遍历每个楼梯，计算方法数。
  • 空间复杂度：O(1)，只用了常数空间存储状态。

找到最长上升子序列（LIS）

解析：最长上升子序列（LIS）问题是给定一个数组，求出其中的最长递增子序列。这个问题可以用动态规划（DP）来解决，状态转移方程为：dp[i]=max⁡(dp[i],dp[j]+1) for all j < i and nums[j] < nums[i]。最终的答案是所有 dp[i] 中的最大值。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class LongestIncreasingSubsequence {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int[] dp = new int[nums.length];
        int maxLength = 1;
        for (int i = 0; i < nums.length; i++) {
            dp[i] = 1;  // 最长递增子序列至少是该元素本身
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLength = Math.max(maxLength, dp[i]);
        }
        return maxLength;
    }

    public static void main(String[] args) {
        LongestIncreasingSubsequence solution = new LongestIncreasingSubsequence();
        int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
        System.out.println(solution.lengthOfLIS(nums));  // Output: 4
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n^2)，双重循环遍历所有元素。
  • 空间复杂度：O(n)，存储 dp 数组。

优化：通过二分查找优化至 O(nlog⁡n)。

找零钱问题：给定硬币面值数组，求最少硬币数使得总金额为目标值

解析：找零钱问题是一个典型的动态规划问题。可以通过定义一个数组 dp[i] 来表示金额 i 需要的最少硬币数。状态转移方程为：dp[i]=min⁡(dp[i],dp[i−coin]+1) 其中 coin 是硬币的面值。最后返回 dp[target] 即为答案。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class CoinChange {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, amount + 1);  // 用一个大值初始化
        dp[0] = 0;  // 零金额不需要硬币
        // 遍历硬币
        for (int coin : coins) {
            // i表示金额，dp[i]表示当前金额所需的最小硬币数
            for (int i = coin; i <= amount; i++) {
                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
            }
        }
        return dp[amount] > amount ? -1 : dp[amount];
    }

    public static void main(String[] args) {
        CoinChange solution = new CoinChange();
        int[] coins = {1, 2, 5};
        System.out.println(solution.coinChange(coins, 11));  // Output: 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n×m)，其中 n 是目标金额，m 是硬币的数量。
  • 空间复杂度：O(n)，用于存储 dp 数组。

编辑距离问题：计算两个字符串的最小编辑距离

解析：编辑距离问题是计算将字符串 A 转换成字符串 B 所需的最小操作次数，允许的操作有：插入、删除和替换字符。这个问题使用动态规划解决，定义 dp[i][j] 为将 A[0..i−1] 转换为 B[0..j−1] 的最小操作数。状态转移方程为： dp[i][j] = min⁡(dp[i−1][j] + 1, dp[i][j−1] + 1, dp[i−1][j−1] + (A[i−1]==B[j−1]?0:1))

公式推导：

dp[i][j] 表示将字符串 A 的前 i 个字符转换为字符串 B 的前 j 个字符所需的最小编辑步骤数。

计算 dp[i][j] 时，我们有三种情况：

  1. 删除 A[i-1]（即 A[0…i-1] 的最后一个字符）
    • 此时 A[0...i-2] 需要变成 B[0...j-1]，然后再**删除 A[i-1]**。
    • 所以 dp[i][j] = dp[i-1][j] + 1（+1 表示删除 A[i-1]）。
  2. 插入 B[j-1]（使 A[0…i-1] 变得和 B[0…j-1] 相等）
    • 先让 A[0...i-1] 变成 B[0...j-2]，然后再**插入 B[j-1]**。
    • 所以 dp[i][j] = dp[i][j-1] + 1（+1 表示插入 B[j-1]）。
  3. 替换 A[i-1] 变成 B[j-1]（或者如果已经相等就不操作）
    • 先让 A[0...i-2] 变成 B[0...j-2] ，然后：
      • 如果 A[i-1] == B[j-1]，则不需要额外操作。
      • 否则，需要**替换 A[i-1] 为 B[j-1]**。
    • 所以 dp[i][j] = dp[i-1][j-1] + (A[i-1] == B[j-1] ? 0 : 1)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class EditDistance {
    public int minDistance(String word1, String word2) {
        int m = word1.length(), n = word2.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 0; i <= m; i++) dp[i][0] = i;
        for (int j = 0; j <= n; j++) dp[0][j] = j;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                }
            }
        }
        return dp[m][n];
    }

    public static void main(String[] args) {
        EditDistance solution = new EditDistance();
        System.out.println(solution.minDistance("horse", "ros"));  // Output: 3
    }
}

时间和空间复杂度：

  • 时间复杂度：O(m×n)，需要遍历二维数组。
  • 空间复杂度：O(m×n)，用于存储 dp 数组。

优化：可以将空间复杂度优化为 O(min⁡(m,n))，只保留上一行或上一列。

4. 贪心算法

分发糖果问题

解析：

分发糖果问题是给定一个学生的评分数组，每个学生至少要分配一个糖果，且如果一个学生的评分高于邻居，则该学生分配的糖果数要多于邻居。问题的目标是最小化糖果的总数。

解决方案：可以采用贪心算法，首先从左到右遍历，确保每个学生的糖果数比前面的学生多（如果评分较高）；然后从右到左遍历，确保每个学生的糖果数比后面的学生多（如果评分较高）。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class Candy {
    public int candy(int[] ratings) {
        if (ratings == null || ratings.length == 0) return 0;
        
        int n = ratings.length;
        int[] candies = new int[n];
        Arrays.fill(candies, 1);  // 每个学生至少一个糖果
        
        // 从左到右遍历
        for (int i = 1; i < n; i++) {
            if (ratings[i] > ratings[i - 1]) {
                candies[i] = candies[i - 1] + 1;
            }
        }

        // 从右到左遍历
        for (int i = n - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                candies[i] = Math.max(candies[i], candies[i + 1] + 1);
            }
        }
        
        int result = 0;
        for (int candy : candies) {
            result += candy;
        }
        
        return result;
    }

    public static void main(String[] args) {
        Candy solution = new Candy();
        int[] ratings = {1, 0, 2};
        System.out.println(solution.candy(ratings));  // Output: 5
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)O(n)，需要两次遍历评分数组。
  • 空间复杂度：O(n)O(n)，需要额外的 candies 数组存储糖果数。

合并区间问题

解析：

给定一组区间，要求合并所有重叠的区间。可以首先对区间按起始位置排序，然后遍历区间，合并重叠部分。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.*;

public class MergeIntervals {
    public int[][] merge(int[][] intervals) {
        if (intervals == null || intervals.length == 0) return new int[0][0];
        
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        
        List<int[]> merged = new ArrayList<>();
        merged.add(intervals[0]);
        
        for (int i = 1; i < intervals.length; i++) {
            int[] last = merged.get(merged.size() - 1);
            if (intervals[i][0] <= last[1]) {
                last[1] = Math.max(last[1], intervals[i][1]);
            } else {
                merged.add(intervals[i]);
            }
        }
        
        return merged.toArray(new int[merged.size()][]);
    }

    public static void main(String[] args) {
        MergeIntervals solution = new MergeIntervals();
        int[][] intervals = {{1, 3}, {2, 6}, {8, 10}, {15, 18}};
        System.out.println(Arrays.deepToString(solution.merge(intervals)));  // Output: [[1, 6], [8, 10], [15, 18]]
    }
}

时间和空间复杂度：

  • 时间复杂度：O(nlog⁡n)O(n \log n)，排序的时间复杂度是主导因素。
  • 空间复杂度：O(n)O(n)，需要存储合并后的区间。

找出可以装入背包的最大价值（0/1 背包问题）

解析：

0/1 背包问题是一个经典的动态规划问题。给定一组物品，每个物品有一个重量和价值，目标是从中选择物品，使得总重量不超过背包容量，且总价值最大。我们使用动态规划来求解，定义状态 dp[i][j]dp[i][j] 为前 ii 个物品在背包容量为 jj 的情况下能获得的最大价值。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Knapsack {
    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 = 1; 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 static void main(String[] args) {
        Knapsack solution = new Knapsack();
        int[] weights = {2, 3, 4, 5};
        int[] values = {3, 4, 5, 6};
        int capacity = 5;
        System.out.println(solution.knapsack(weights, values, capacity));  // Output: 7
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n×W)O(n \times W)，其中 nn 是物品数量，WW 是背包容量。
  • 空间复杂度：O(n×W)O(n \times W)，用于存储 dpdp 数组。

活动选择问题

解析：

活动选择问题要求从一组活动中选择尽可能多的活动，使得它们之间不会重叠。这个问题可以通过贪心算法来解决：首先按活动的结束时间进行排序，然后从第一个活动开始选择每个结束时间最早的活动。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.*;

public class ActivitySelection {
    public int activitySelection(int[][] activities) {
        Arrays.sort(activities, Comparator.comparingInt(a -> a[1]));  // 按结束时间排序
        
        int count = 1;  // 至少可以选第一个活动
        int lastEndTime = activities[0][1];
        
        for (int i = 1; i < activities.length; i++) {
            if (activities[i][0] >= lastEndTime) {  // 如果当前活动的开始时间大于等于上一个活动的结束时间
                count++;
                lastEndTime = activities[i][1];
            }
        }
        
        return count;
    }

    public static void main(String[] args) {
        ActivitySelection solution = new ActivitySelection();
        int[][] activities = {{1, 3}, {2, 5}, {4, 6}, {6, 7}, {5, 8}};
        System.out.println(solution.activitySelection(activities));  // Output: 4
    }
}

时间和空间复杂度：

  • 时间复杂度：O(nlog⁡n)O(n \log n)，排序的时间复杂度是主导因素。
  • 空间复杂度：O(1)O(1)，只用了常数空间。

高级算法题

1. 位运算

  • 找到数组中只出现一次的数字（其他数字出现两次）。
  • 找出两个整数的二进制位的不同个数。
  • 不使用加减乘除实现加法。

找到数组中只出现一次的数字（其他数字出现两次）

解析：

可以通过异或操作来解决这个问题。由于异或具有交换律和结合律，并且 x⊕x=0x \oplus x = 0x⊕x=0，所有出现两次的数字会被消除，最终结果即为只出现一次的数字。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
javaCopyEditpublic class SingleNumber {
    public int singleNumber(int[] nums) {
        int result = 0;
        for (int num : nums) {
            result ^= num;  // 对所有数字进行异或操作
        }
        return result;
    }

    public static void main(String[] args) {
        SingleNumber solution = new SingleNumber();
        int[] nums = {4, 1, 2, 1, 2};
        System.out.println(solution.singleNumber(nums));  // Output: 4
    }
}

时间和空间复杂度：

  • 时间复杂度：O(n)O(n)O(n)，需要遍历整个数组。
  • 空间复杂度：O(1)O(1)O(1)，只用了常数空间。

找出两个整数的二进制位的不同个数

解析：

可以通过异或操作得到两个整数的二进制位不同的部分，然后统计该部分的 1 的个数。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
javaCopyEditpublic class HammingDistance {
    public int hammingDistance(int x, int y) {
        int xor = x ^ y;  // 获取不同的二进制位
        int count = 0;
        while (xor != 0) {
            count += xor & 1;  // 每次检查最低位是否为1
            xor >>= 1;  // 右移
        }
        return count;
    }

    public static void main(String[] args) {
        HammingDistance solution = new HammingDistance();
        System.out.println(solution.hammingDistance(1, 4));  // Output: 2
    }
}

时间和空间复杂度：

  • 时间复杂度：O(log⁡n)O(\log n)O(logn)，因为每次右移一位，最多需要处理 O(log⁡n)O(\log n)O(logn) 次。
  • 空间复杂度：O(1)O(1)O(1)，只用了常数空间。

不使用加减乘除实现加法

解析：

可以通过位运算实现加法。异或运算可以模拟加法的无进位部分，进位部分可以通过与运算计算出来，并左移一位再加到无进位部分上，直到进位为 0。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
javaCopyEditpublic class AddWithoutOperator {
    public int add(int a, int b) {
        while (b != 0) {
            int carry = a & b;  // 计算进位
            a = a ^ b;  // 无进位加法
            b = carry << 1;  // 进位左移
        }
        return a;
    }

    public static void main(String[] args) {
        AddWithoutOperator solution = new AddWithoutOperator();
        System.out.println(solution.add(5, 7));  // Output: 12
    }
}

时间和空间复杂度：

  • 时间复杂度：O(log⁡n)O(\log n)O(logn)，因为每次进位左移。
  • 空间复杂度：O(1)O(1)O(1)，只用了常数空间。

总结

问题 时间复杂度 空间复杂度
分发糖果问题 O(n)O(n) O(n)O(n)
合并区间问题 O(nlog⁡n)O(n \log n) O(n)O(n)
0/1 背包问题 O(n×W)O(n \times W) O(n×W)O(n \times W)
活动选择问题 O(nlog⁡n)O(n \log n) O(1)O(1)
找到只出现一次的数字 O(n)O(n) O(1)O(1)
找出两个整数的二进制位差异 O(log⁡n)O(\log n) O(1)O(1)
不使用加减乘除实现加法 O(log⁡n)O(\log n) O(1)O(1)

这些问题涵盖了常见的贪心算法、动态规划、位运算等常用技巧，适用于面试中的基础算法题。

2. 分治法

  • 实现大整数的快速乘法（Karatsuba 算法）。
  • 求数组中的逆序对个数。

下面是你提到的基础算法的解析、代码实现、时间复杂度和空间复杂度分析：

实现大整数的快速乘法（Karatsuba 算法）

解析：

Karatsuba 算法通过分治法来实现大整数乘法，可以将时间复杂度从 O(n2)O(n^2) 降低到 O(nlog⁡23)O(n^{\log_2 3})（约为 O(n1.585)O(n^{1.585})）。该算法将两个大整数分为两部分，然后递归计算它们的乘积。

基本思想：

  • 将两个大整数 xx 和 yy 分为两部分：高位和低位。
  • 计算三个部分的乘积：
    1. z0=low1×low2z_0 = \text{low1} \times \text{low2}
    2. z1=(low1+high1)×(low2+high2)z_1 = (\text{low1} + \text{high1}) \times (\text{low2} + \text{high2})
    3. z2=high1×high2z_2 = \text{high1} \times \text{high2}
  • 使用这些结果计算最终的乘积。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Karatsuba {
    public static long karatsuba(long x, long y) {
        // 基础情形：数字足够小，直接计算
        if (x < 10 || y < 10) {
            return x * y;
        }

        int m = Math.max(Long.toString(x).length(), Long.toString(y).length());
        int half = m / 2;

        long high1 = x / (long) Math.pow(10, half);
        long low1 = x % (long) Math.pow(10, half);
        long high2 = y / (long) Math.pow(10, half);
        long low2 = y % (long) Math.pow(10, half);

        // 递归调用
        long z0 = karatsuba(low1, low2);
        long z1 = karatsuba(low1 + high1, low2 + high2);
        long z2 = karatsuba(high1, high2);

        // 计算最终结果
        return z2 * (long) Math.pow(10, 2 * half) + (z1 - z2 - z0) * (long) Math.pow(10, half) + z0;
    }

    public static void main(String[] args) {
        System.out.println(karatsuba(1234, 5678));  // Output: 7006652
    }
}

时间和空间复杂度：

  • 时间复杂度：O(nlog⁡23)O(n^{\log_2 3})，通过分治法将时间复杂度降低。
  • 空间复杂度：O(n)O(n)，递归调用栈的空间消耗。

求数组中的逆序对个数

解析：

逆序对是数组中一对元素 (i,j)(i, j)，满足 i<ji < j 且 arr[i]>arr[j]arr[i] > arr[j]。可以通过修改归并排序来解决，时间复杂度为 O(nlog⁡n)O(n \log n)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class InversionCount {
    public static int mergeCount(int[] arr, int[] temp, int left, int right) {
        if (left == right) {
            return 0;
        }

        int mid = (left + right) / 2;
        int count = mergeCount(arr, temp, left, mid) + mergeCount(arr, temp, mid + 1, right);
        count += merge(arr, temp, left, mid, right);
        return count;
    }

    private static int merge(int[] arr, int[] temp, int left, int mid, int right) {
        int i = left, j = mid + 1, k = left, count = 0;

        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
                count += (mid - i + 1);  // 逆序对数目
            }
        }

        while (i <= mid) {
            temp[k++] = arr[i++];
        }

        while (j <= right) {
            temp[k++] = arr[j++];
        }

        System.arraycopy(temp, left, arr, left, right - left + 1);
        return count;
    }

    public static int countInversions(int[] arr) {
        int[] temp = new int[arr.length];
        return mergeCount(arr, temp, 0, arr.length - 1);
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 2, 4, 1};
        System.out.println(countInversions(arr));  // Output: 10
    }
}

时间和空间复杂度：

  • 时间复杂度：O(nlog⁡n)O(n \log n)，通过归并排序合并子数组。
  • 空间复杂度：O(n)O(n)，需要额外的临时数组。

3. 高级数据结构

  • 实现 LRU 缓存机制。
  • 用栈实现队列。
  • 设计一个支持常数时间插入、删除和随机访问的数据结构。

实现 LRU 缓存机制

解析：

LRU（Least Recently Used）缓存机制要求在缓存已满时，淘汰最久未使用的元素。可以使用 双向链表 和 哈希表 的结合来实现。

  • 哈希表用于快速查找元素。
  • 双向链表用于维护元素的访问顺序，头部表示最近使用，尾部表示最久未使用。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.*;

public class LRUCache {
    private int capacity;
    private Map<Integer, Integer> cache;
    private LinkedHashMap<Integer, Long> accessOrder;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        cache = new HashMap<>(capacity);
        accessOrder = new LinkedHashMap<>(capacity, 0.75f, true);  // 使用LRU策略
    }

    public int get(int key) {
        if (!cache.containsKey(key)) {
            return -1;
        }
        accessOrder.put(key, System.nanoTime());  // 更新使用时间
        return cache.get(key);
    }

    public void put(int key, int value) {
        if (cache.size() >= capacity) {
            // 找到并删除访问最少的元素
            long oldest = Long.MAX_VALUE;
            int keyToRemove = -1;
            for (Map.Entry<Integer, Long> entry : accessOrder.entrySet()) {
                if (entry.getValue() < oldest) {
                    oldest = entry.getValue();
                    keyToRemove = entry.getKey();
                }
            }
            cache.remove(keyToRemove);
            accessOrder.remove(keyToRemove);
        }
        cache.put(key, value);
        accessOrder.put(key, System.nanoTime());
    }

    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(2);
        lruCache.put(1, 1);
        lruCache.put(2, 2);
        System.out.println(lruCache.get(1));  // Output: 1
        lruCache.put(3, 3);                  // Evicts key 2
        System.out.println(lruCache.get(2));  // Output: -1
    }
}

时间和空间复杂度：

  • 时间复杂度：get 和 put 操作的时间复杂度为 O(1)O(1)，因为哈希表提供常数时间的查找和插入。
  • 空间复杂度：O(n)O(n)，缓存存储大小为 nn。

用栈实现队列

解析：

可以使用两个栈来模拟队列。一个栈用于入队，另一个栈用于出队。当出队栈为空时，将入队栈的元素全部转移到出队栈中，这样就可以实现队列的先进先出（FIFO）特性。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.util.*;

public class MyQueue {
    private Stack<Integer> stack1;
    private Stack<Integer> stack2;

    public MyQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }

    public void push(int x) {
        stack1.push(x);
    }

    public int pop() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }

    public int peek() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }

    public boolean empty() {
        return stack1.isEmpty() && stack2.isEmpty();
    }

    public static void main(String[] args) {
        MyQueue queue = new MyQueue();
        queue.push(1);
        queue.push(2);
        System.out.println(queue.peek());  // Output: 1
        System.out.println(queue.pop());   // Output: 1
        System.out.println(queue.empty()); // Output: false
    }
}

时间和空间复杂度：

  • 时间复杂度：push 操作为

O(1)O(1)，pop 和 peek 操作的最坏时间复杂度为 O(n)O(n)，因为每次都需要将所有元素从一个栈移动到另一个栈。

  • 空间复杂度：O(n)O(n)，需要存储两个栈。

设计一个支持常数时间插入、删除和随机访问的数据结构

解析：

为了支持常数时间的插入、删除和随机访问，可以使用一个 哈希表 和一个 动态数组 的结合。哈希表用于通过值查找索引，动态数组用于存储元素并支持随机访问。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.*;

public class RandomizedSet {
    private Map<Integer, Integer> map;
    private List<Integer> list;

    public RandomizedSet() {
        map = new HashMap<>();
        list = new ArrayList<>();
    }

    public boolean insert(int val) {
        if (map.containsKey(val)) return false;
        map.put(val, list.size());
        list.add(val);
        return true;
    }

    public boolean remove(int val) {
        if (!map.containsKey(val)) return false;
        int index = map.get(val);
        int lastElement = list.get(list.size() - 1);
        list.set(index, lastElement);
        map.put(lastElement, index);
        list.remove(list.size() - 1);
        map.remove(val);
        return true;
    }

    public int getRandom() {
        Random rand = new Random();
        return list.get(rand.nextInt(list.size()));
    }

    public static void main(String[] args) {
        RandomizedSet randomizedSet = new RandomizedSet();
        System.out.println(randomizedSet.insert(1)); // true
        System.out.println(randomizedSet.remove(2)); // false
        System.out.println(randomizedSet.insert(2)); // true
        System.out.println(randomizedSet.getRandom()); // 1 or 2
    }
}

时间和空间复杂度：

  • 时间复杂度

    ：

    • insert 和 remove 操作：O(1)O(1)，因为我们通过哈希表和数组的索引来进行操作。
    • getRandom 操作：O(1)O(1)，因为随机访问数组是常数时间操作。

  • 空间复杂度：O(n)O(n)，存储哈希表和动态数组。

总结

算法 时间复杂度 空间复杂度
Karatsuba 快速乘法 O(nlog⁡23)O(n^{\log_2 3}) O(n)O(n)
逆序对计数 O(nlog⁡n)O(n \log n) O(n)O(n)
LRU 缓存 O(1)O(1) O(n)O(n)
用栈实现队列 O(1)O(1) (均摊) O(n)O(n)
支持常数时间插入删除 O(1)O(1) O(n)O(n)

这些算法覆盖了从数值计算到数据结构设计的不同应用，展示了高效的操作和实现技巧。

4. 图论与网络流

  • 最短路径问题（Dijkstra 算法，Floyd-Warshall 算法）。
  • 最小生成树（Kruskal 或 Prim 算法）。
  • 拓扑排序。
  • 最大流问题（Edmonds-Karp 算法）。

以下是你要求的各个基础算法的解析、代码、时间复杂度和空间复杂度。

最短路径问题（Dijkstra 算法，Floyd-Warshall 算法）

Dijkstra 算法

解析： Dijkstra 算法用于计算从单个源节点到所有其他节点的最短路径。适用于边权非负的图。它通过贪心算法每次选择当前距离源节点最近的未处理节点来逐步扩展最短路径。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.util.*;

public class Dijkstra {
    public static int[] dijkstra(int[][] graph, int source) {
        int n = graph.length;
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[source] = 0;
        boolean[] visited = new boolean[n];

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
        pq.offer(new int[]{source, 0});

        while (!pq.isEmpty()) {
            int[] current = pq.poll();
            int u = current[0];

            if (visited[u]) continue;
            visited[u] = true;

            for (int v = 0; v < n; v++) {
                if (graph[u][v] != 0 && !visited[v]) {
                    int newDist = dist[u] + graph[u][v];
                    if (newDist < dist[v]) {
                        dist[v] = newDist;
                        pq.offer(new int[]{v, dist[v]});
                    }
                }
            }
        }
        return dist;
    }

    public static void main(String[] args) {
        int[][] graph = {
            {0, 1, 4, 0, 0, 0},
            {1, 0, 4, 2, 7, 0},
            {4, 4, 0, 3, 5, 0},
            {0, 2, 3, 0, 4, 6},
            {0, 7, 5, 4, 0, 7},
            {0, 0, 0, 6, 7, 0}
        };
        int[] dist = dijkstra(graph, 0);
        System.out.println(Arrays.toString(dist));  // Output: [0, 1, 4, 3, 7, 9]
    }
}

时间复杂度： O(Elog⁡V)O(E \log V)，其中 VV 是顶点数，EE 是边数。 空间复杂度： O(V+E)O(V + E)，需要存储图、距离数组和优先队列。

Floyd-Warshall 算法

解析： Floyd-Warshall 算法用于计算所有节点对之间的最短路径，适用于带负权边的图（不含负权回路）。它使用动态规划逐步更新路径矩阵。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class FloydWarshall {
    public static int[][] floydWarshall(int[][] graph) {
        int n = graph.length;
        int[][] dist = new int[n][n];

        // 初始化距离矩阵
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) dist[i][j] = 0;
                else if (graph[i][j] != 0) dist[i][j] = graph[i][j];
                else dist[i][j] = Integer.MAX_VALUE;
            }
        }

        // 逐步更新路径矩阵
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (dist[i][k] != Integer.MAX_VALUE && dist[k][j] != Integer.MAX_VALUE) {
                        dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
        }
        return dist;
    }

    public static void main(String[] args) {
        int[][] graph = {
            {0, 3, 0, 0, 0, 0},
            {3, 0, 2, 1, 0, 0},
            {0, 2, 0, 4, 6, 0},
            {0, 1, 4, 0, 5, 2},
            {0, 0, 6, 5, 0, 4},
            {0, 0, 0, 2, 4, 0}
        };
        int[][] dist = floydWarshall(graph);
        for (int[] row : dist) {
            System.out.println(Arrays.toString(row));
        }
    }
}

时间复杂度： O(V3)O(V^3)，适用于小规模图。 空间复杂度： O(V2)O(V^2)，需要存储距离矩阵。

最小生成树（Kruskal 或 Prim 算法）

Kruskal 算法

解析： Kruskal 算法是基于边的贪心算法，选择权重最小的边，逐步合并不同的集合，直到形成一个最小生成树。需要使用并查集（Union-Find）来判断是否形成环。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.util.*;

public class Kruskal {
    static class Edge {
        int u, v, weight;
        Edge(int u, int v, int weight) {
            this.u = u;
            this.v = v;
            this.weight = weight;
        }
    }

    static class UnionFind {
        int[] parent, rank;
        UnionFind(int n) {
            parent = new int[n];
            rank = new int[n];
            for (int i = 0; i < n; i++) parent[i] = i;
        }

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

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

    public static int kruskal(int n, List<Edge> edges) {
        edges.sort(Comparator.comparingInt(e -> e.weight));
        UnionFind uf = new UnionFind(n);
        int mstWeight = 0;

        for (Edge edge : edges) {
            if (uf.find(edge.u) != uf.find(edge.v)) {
                uf.union(edge.u, edge.v);
                mstWeight += edge.weight;
            }
        }
        return mstWeight;
    }

    public static void main(String[] args) {
        List<Edge> edges = new ArrayList<>();
        edges.add(new Edge(0, 1, 1));
        edges.add(new Edge(0, 2, 2));
        edges.add(new Edge(1, 2, 1));
        edges.add(new Edge(1, 3, 3));
        edges.add(new Edge(2, 3, 4));
        System.out.println(kruskal(4, edges));  // Output: 6
    }
}

时间复杂度： O(Elog⁡E)O(E \log E)，边排序的时间复杂度。 空间复杂度： O(V+E)O(V + E)，需要存储边和并查集。

Prim 算法

解析： Prim 算法是基于顶点的贪心算法，每次从已连接的点中选择权重最小的边来扩展最小生成树。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.*;

public class Prim {
    public static int prim(int n, int[][] graph) {
        boolean[] visited = new boolean[n];
        int[] minEdge = new int[n];
        Arrays.fill(minEdge, Integer.MAX_VALUE);
        minEdge[0] = 0;  // 从第一个顶点开始
        int mstWeight = 0;

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
        pq.offer(new int[]{0, 0});

        while (!pq.isEmpty()) {
            int[] current = pq.poll();
            int u = current[0], weight = current[1];

            if (visited[u]) continue;
            visited[u] = true;
            mstWeight += weight;

            for (int v = 0; v < n; v++) {
                if (!visited[v] && graph[u][v] != 0 && graph[u][v] < minEdge[v]) {
                    minEdge[v] = graph[u][v];
                    pq.offer(new int[]{v, graph[u][v]});
                }
            }
        }
        return mstWeight;
    }

    public static void main(String[] args) {
        int[][]

graph = { {0, 1, 2, 0}, {1, 0, 1, 3}, {2, 1, 0, 4}, {0, 3, 4, 0} }; System.out.println(prim(4, graph)); // Output: 6 } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
**时间复杂度：** \(O(E \log V)\)，使用优先队列。
**空间复杂度：** \(O(V + E)\)。

---

#### 拓扑排序

**解析：**
拓扑排序用于有向无环图（DAG），它将图中的顶点按照依赖关系进行排序，确保每个顶点都排在其所有依赖顶点之前。

**代码实现：**
```java
import java.util.*;

public class TopologicalSort {
    public static List<Integer> topologicalSort(int n, int[][] graph) {
        int[] inDegree = new int[n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (graph[i][j] != 0) inDegree[j]++;
            }
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (inDegree[i] == 0) queue.offer(i);
        }

        List<Integer> result = new ArrayList<>();
        while (!queue.isEmpty()) {
            int u = queue.poll();
            result.add(u);

            for (int v = 0; v < n; v++) {
                if (graph[u][v] != 0 && --inDegree[v] == 0) {
                    queue.offer(v);
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] graph = {
            {0, 1, 0, 0},
            {0, 0, 1, 0},
            {0, 0, 0, 1},
            {0, 0, 0, 0}
        };
        System.out.println(topologicalSort(4, graph));  // Output: [0, 1, 2, 3]
    }
}

时间复杂度： O(V+E)O(V + E)，需要遍历所有的顶点和边。 空间复杂度： O(V+E)O(V + E)，存储图和入度数组。

最大流问题（Edmonds-Karp 算法）

解析： Edmonds-Karp 算法是 Ford-Fulkerson 算法的实现，它通过广度优先搜索（BFS）找到增广路径，并增加流量，直到无法找到增广路径。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import java.util.*;

public class EdmondsKarp {
    static final int INF = Integer.MAX_VALUE;

    public static int bfs(int[][] capacity, int[] parent, int source, int sink) {
        int n = capacity.length;
        boolean[] visited = new boolean[n];
        Arrays.fill(parent, -1);
        visited[source] = true;

        Queue<Integer> queue = new LinkedList<>();
        queue.offer(source);

        while (!queue.isEmpty()) {
            int u = queue.poll();
            for (int v = 0; v < n; v++) {
                if (!visited[v] && capacity[u][v] > 0) {
                    visited[v] = true;
                    parent[v] = u;
                    if (v == sink) return 1;
                    queue.offer(v);
                }
            }
        }
        return 0;
    }

    public static int edmondsKarp(int[][] capacity, int source, int sink) {
        int n = capacity.length;
        int[] parent = new int[n];
        int maxFlow = 0;

        while (bfs(capacity, parent, source, sink) == 1) {
            int pathFlow = INF;
            for (int v = sink; v != source; v = parent[v]) {
                int u = parent[v];
                pathFlow = Math.min(pathFlow, capacity[u][v]);
            }

            for (int v = sink; v != source; v = parent[v]) {
                int u = parent[v];
                capacity[u][v] -= pathFlow;
                capacity[v][u] += pathFlow;
            }

            maxFlow += pathFlow;
        }
        return maxFlow;
    }

    public static void main(String[] args) {
        int[][] capacity = {
            {0, 16, 13, 0, 0, 0},
            {0, 0, 10, 12, 0, 0},
            {0, 0, 0, 9, 14, 0},
            {0, 0, 0, 0, 0, 20},
            {0, 0, 0, 7, 0, 4},
            {0, 0, 0, 0, 0, 0}
        };

        System.out.println(edmondsKarp(capacity, 0, 5));  // Output: 23
    }
}

时间复杂度： O(V×E2)O(V \times E^2)，BFS每次查找增广路径，最多进行 EE 次，每次增广可能消耗 O(V)O(V) 时间。 空间复杂度： O(V2)O(V^2)，需要存储容量矩阵。

5. 字符串匹配

  • 实现 KMP 算法。
  • 查找字符串中最长的回文子串。
  • 实现 Trie 树。

实现 KMP 算法

解析： KMP（Knuth-Morris-Pratt）算法用于高效地查找字符串中的子串。它通过预处理模式串来避免多余的字符匹配。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class KMP {
    public static int[] buildLPS(String pattern) {
        int m = pattern.length();
        int[] lps = new int[m];
        int length = 0;  // 长度为当前最长前后缀长度
        int i = 1;
        while (i < m) {
            if (pattern.charAt(i) == pattern.charAt(length)) {
                length++;
                lps[i] = length;
                i++;
            } else {
                if (length != 0) {
                    length = lps[length - 1];
                } else {
                    lps[i] = 0;
                    i++;
                }
            }
        }
        return lps;
    }

    public static int KMPsearch(String text, String pattern) {
        int n = text.length();
        int m = pattern.length();
        int[] lps = buildLPS(pattern);
        int i = 0, j = 0;

        while (i < n) {
            if (pattern.charAt(j) == text.charAt(i)) {
                i++;
                j++;
            }

            if (j == m) {
                return i - j;  // 找到匹配
            } else if (i < n && pattern.charAt(j) != text.charAt(i)) {
                if (j != 0) {
                    j = lps[j - 1];
                } else {
                    i++;
                }
            }
        }
        return -1;  // 未找到匹配
    }

    public static void main(String[] args) {
        String text = "ABABDABACDABABCABAB";
        String pattern = "ABABCABAB";
        System.out.println(KMPsearch(text, pattern));  // Output: 10
    }
}

时间复杂度： O(n+m)O(n + m)，其中 nn 是文本长度，mm 是模式串长度。 空间复杂度： O(m)O(m)，需要存储最长前后缀数组。

查找字符串中最长的回文子串

解析： 该问题要求找到字符串中的最长回文子串，可以使用动态规划来解决。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class LongestPalindromicSubstring {
    public static String longestPalindrome(String s) {
        int n = s.length();
        if (n == 0) return "";

        boolean[][] dp = new boolean[n][n];
        String longest = "";

        for (int len = 1; len <= n; len++) {
            for (int i = 0; i <= n - len; i++) {
                int j = i + len - 1;
                if (len == 1) dp[i][j] = true;
                else if (len == 2) dp[i][j] = (s.charAt(i) == s.charAt(j));
                else dp[i][j] = (s.charAt(i) == s.charAt(j)) && dp[i + 1][j - 1];

                if (dp[i][j] && len > longest.length()) {
                    longest = s.substring(i, j + 1);
                }
            }
        }
        return longest;
    }

    public static void main(String[] args) {
        String s = "babad";
        System.out.println(longestPalindrome(s));  // Output: "bab" or "aba"
    }
}

时间复杂度： O(n2)O(n^2)，需要填充一个 n×nn \times n 的动态规划表。 空间复杂度： O(n2)O(n^2)，存储动态规划表。

实现Trie 树

解析： Trie 树是一种用于存储字符串的树形数据结构，可以高效地进行前缀查找。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class Trie {
    static class TrieNode {
        TrieNode[] children = new TrieNode[26];
        boolean isEndOfWord;
    }

    private TrieNode root;

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

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

    public boolean search(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            int index = c - 'a';
            if (node.children[index] == null) {
                return false;
            }
            node = node.children[index];
        }
        return node.isEndOfWord;
    }

    public boolean startsWith(String prefix) {
        TrieNode node = root;
        for (char c : prefix.toCharArray()) {
            int index = c - 'a';
            if (node.children[index] == null) {
                return false;
            }
            node = node.children[index];
        }
        return true;
    }

    public static void main(String[] args) {
        Trie trie = new Trie();
        trie.insert("apple");
        System.out.println(trie.search("apple"));  // Output: true
        System.out.println(trie.search("app"));    // Output: false
        System.out.println(trie.startsWith("app")); // Output: true
    }
}

时间复杂度： O(m)O(m)，其中 mm 是单词的长度。 空间复杂度： O(m×N)O(m \times N)，mm 是单词的长度，NN 是字符集的大小。

实际应用场景题

  1. 实现一个固定大小的滑动窗口最大值。
  2. 模拟生产者消费者问题。
  3. 设计一个电梯调度算法。
  4. 给定一组会议时间段，判断是否可以安排所有会议。
  5. 分配任务给员工，使得完成所有任务所需的时间最短。

实现一个固定大小的滑动窗口最大值

解析： 滑动窗口最大值问题要求在一个固定大小的窗口内，找到每个位置的最大值。可以使用双端队列（Deque）来解决，队列保持索引，保证队列中的元素是按值递减的，这样每次滑动窗口时，我们可以高效地获取当前窗口的最大值。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.util.*;

public class SlidingWindowMaximum {
    public static int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k == 0) return new int[0];
        
        int n = nums.length;
        int[] result = new int[n - k + 1];
        Deque<Integer> deque = new LinkedList<>();
        
        for (int i = 0; i < n; i++) {
            // 移除窗口外的元素
            if (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
                deque.pollFirst();
            }
            
            // 保持队列内元素的递减性
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            
            deque.offerLast(i);
            
            // 从第 k 个元素开始记录最大值
            if (i >= k - 1) {
                result[i - k + 1] = nums[deque.peekFirst()];
            }
        }
        
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
        int k = 3;
        System.out.println(Arrays.toString(maxSlidingWindow(nums, k)));
    }
}

时间复杂度： O(n)O(n)，每个元素最多被访问两次（一次进队列，一次出队列）。 空间复杂度： O(k)O(k)，队列的最大空间使用为 kk。

模拟生产者消费者问题

解析： 生产者消费者问题是一个经典的多线程问题，生产者生产数据并将其放入缓冲区，而消费者从缓冲区获取数据。我们可以使用 wait() 和 notify() 来协调生产者和消费者之间的同步。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.util.*;

class ProducerConsumer {
    private static final int MAX_SIZE = 10;
    private final Queue<Integer> queue = new LinkedList<>();

    // 生产者线程
    class Producer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == MAX_SIZE) {
                        try {
                            queue.wait();  // 缓冲区满，等待消费者消费
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    queue.offer((int) (Math.random() * 100));
                    System.out.println("Produced item, queue size: " + queue.size());
                    queue.notifyAll();  // 通知消费者可以消费
                }
            }
        }
    }

    // 消费者线程
    class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.isEmpty()) {
                        try {
                            queue.wait();  // 缓冲区空，等待生产者生产
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    queue.poll();
                    System.out.println("Consumed item, queue size: " + queue.size());
                    queue.notifyAll();  // 通知生产者可以生产
                }
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        Thread producerThread = new Thread(pc.new Producer());
        Thread consumerThread = new Thread(pc.new Consumer());

        producerThread.start();
        consumerThread.start();
    }
}

时间复杂度：

  • 生产者和消费者的操作是常数时间操作。
  • 总体时间复杂度取决于线程的数量和执行时间。

空间复杂度： O(n)O(n)，队列最大大小是 MAX_SIZEMAX_SIZE。

设计一个电梯调度算法

解析： 电梯调度算法的目标是根据当前电梯的状态和目标楼层来确定最优的调度策略。常见的方法包括：

  • 最短寻道时间优先（SSTF）：选择离当前电梯最近的请求。
  • 扫描算法（SCAN）：电梯在一方向上移动，直到最远的请求，之后改变方向。

在这里，我们使用一个简单的最短寻道时间优先（SSTF）算法来实现。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.util.*;

public class ElevatorScheduler {
    private static final int MAX_FLOOR = 10;
    private static int currentFloor = 0;
    private static List<Integer> requests = new ArrayList<>();

    public static void addRequest(int floor) {
        if (floor >= 0 && floor < MAX_FLOOR) {
            requests.add(floor);
        }
    }

    public static void processRequests() {
        while (!requests.isEmpty()) {
            // 寻找距离当前楼层最近的请求
            int closestFloor = findClosestFloor();
            System.out.println("Going to floor: " + closestFloor);
            currentFloor = closestFloor;
            requests.remove(Integer.valueOf(closestFloor));
        }
    }

    private static int findClosestFloor() {
        int closest = requests.get(0);
        int minDistance = Math.abs(currentFloor - closest);
        for (int floor : requests) {
            int distance = Math.abs(currentFloor - floor);
            if (distance < minDistance) {
                closest = floor;
                minDistance = distance;
            }
        }
        return closest;
    }

    public static void main(String[] args) {
        addRequest(2);
        addRequest(8);
        addRequest(3);
        addRequest(6);
        processRequests();
    }
}

时间复杂度： O(n2)O(n^2)，每次查找最近楼层需要遍历请求队列，删除操作也需要 O(n)O(n)。 空间复杂度： O(n)O(n)，存储电梯的请求队列。

给定一组会议时间段，判断是否可以安排所有会议

解析： 这个问题可以转化为判断是否有两个会议的时间段重叠。如果有重叠，说明无法安排所有会议。我们可以按会议开始时间排序，检查相邻会议是否有重叠。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.*;

class Meeting {
    int start, end;
    Meeting(int start, int end) {
        this.start = start;
        this.end = end;
    }
}

public class MeetingScheduler {
    public static boolean canScheduleAllMeetings(List<Meeting> meetings) {
        meetings.sort(Comparator.comparingInt(m -> m.start));

        for (int i = 1; i < meetings.size(); i++) {
            if (meetings.get(i).start < meetings.get(i - 1).end) {
                return false;  // 存在重叠，不能安排所有会议
            }
        }
        return true;  // 所有会议可以安排
    }

    public static void main(String[] args) {
        List<Meeting> meetings = new ArrayList<>();
        meetings.add(new Meeting(0, 30));
        meetings.add(new Meeting(5, 10));
        meetings.add(new Meeting(15, 20));

        System.out.println(canScheduleAllMeetings(meetings));  // Output: false
    }
}

时间复杂度： O(nlog⁡n)O(n \log n)，需要对会议进行排序。 空间复杂度： O(n)O(n)，存储会议列表。

分配任务给员工，使得完成所有任务所需的时间最短

解析： 这是一个经典的负载平衡问题。我们希望在任务数量和任务时间不同的情况下，使得每个员工的工作时间尽可能相同。可以通过将任务按时间排序，分配给工作负载最小的员工来实现。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.*;

public class TaskScheduler {
    public static int minimumTime(int[] tasks, int numEmployees) {
        if (numEmployees == 0 || tasks == null || tasks.length == 0) return 0;

        Arrays.sort(tasks);
        int[] employees = new int[numEmployees];  // 员工的工作时间

        for (int i = tasks.length - 1; i >= 0; i--) {
            Arrays.sort(employees);
            employees[0] += tasks[i];  // 给最空闲的员工分配任务
        }

        int maxTime = 0;
        for (int time : employees) {
            maxTime = Math.max(maxTime, time);  // 找到工作时间最长的员工
        }
        return maxTime;
    }

    public static void main(String[] args) {
        int[] tasks = {3, 2, 1, 5, 6, 8};
        int numEmployees = 3;
        System.out.println(minimumTime(tasks, numEmployees));  // Output: 8 } }

时间复杂度： (O(n \log n))，排序任务和员工数组。
空间复杂度： (O(n))，存储任务和员工的工作时间。

四.手撕

问：找出无序数组中相隔距离最长的逆序对？

  • 逆序对的定义是：在数组中，对于一对元素 i,j，如果 i<j 且 arr[i]>arr[j]，则称这对元素为逆序对。
  • 相隔距离：逆序对 (i,j) 的距离是 j−i。

要找出无序数组中相隔距离最长的逆序对，可以采用以下思路：

  1. 确保逆序对满足 arr[i]>arr[j]。
  2. 在所有逆序对中找到距离最大的那对。

解题思路：

  1. 暴力法（O(n^2)）：
    • 通过两层循环，遍历所有的逆序对，记录下最大距离。
    • 时间复杂度为 O(n^2)，空间复杂度为 O(1)，不适合数据量较大的情况。
  2. 优化方法（基于归并排序思想）：
    • 我们可以通过改进的归并排序方法来在 O(nlog⁡n) 时间复杂度内找到逆序对，空间复杂度O(n)，需要额外的数组来进行归并操作。这是一种优化后的方法，适用于较大的数组。如果数组较小，可以使用暴力法。
    • 在归并排序过程中，每当我们进行合并操作时，可以计算逆序对的个数，并且可以追踪这些逆序对的位置，进而找到相隔距离最长的逆序对。

实现代码（优化方法）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public class Solution {
    public int[] findMaxDistanceReversePairs(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return new int[]{-1, -1}; // 无逆序对
        }
        
        // 存储结果的数组，返回最长逆序对的起始位置和终止位置
        int[] result = new int[]{-1, -1};
        int maxDistance = -1;
        
        // 归并排序
        mergeSortAndTrack(arr, 0, arr.length - 1, result);
        
        return result;
    }

    // 递归地分割数组，并在合并过程中记录逆序对的位置
    private void mergeSortAndTrack(int[] arr, int left, int right, int[] result) {
        if (left >= right) return;

        int mid = left + (right - left) / 2;
        mergeSortAndTrack(arr, left, mid, result);
        mergeSortAndTrack(arr, mid + 1, right, result);
        mergeAndCount(arr, left, mid, right, result);
    }

    // 在合并过程中计算逆序对并且更新最大距离的逆序对。具体地，当发现 arr[i]>arr[j]arr[i] > arr[j] 时，我们计算当前逆序对的距离并更新最远的逆序对
    private void mergeAndCount(int[] arr, int left, int mid, int right, int[] result) {
        int[] temp = new int[right - left + 1];
        int i = left, j = mid + 1, k = 0;
        
        // 记录逆序对
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                // 逆序对：arr[i] > arr[j]
                temp[k++] = arr[j++];
                for (int p = i; p <= mid; p++) {
                    int distance = j - p;
                    if (distance > result[1] - result[0]) {
                        result[0] = p;
                        result[1] = j - 1;
                    }
                }
            }
        }
        
        // 将剩余元素放入temp数组
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= right) temp[k++] = arr[j++];
        
        // 把临时数组copy回原数组
        System.arraycopy(temp, 0, arr, left, temp.length);
    }
    
    public static void main(String[] args) {
        Solution solution = new Solution();
        // 给定数组 `[2, 4, 1, 3, 5]`，我们会得到逆序对 `[4, 1]` 和 `[2, 1]`，并返回最大逆序对的位置。
        int[] arr = {2, 4, 1, 3, 5};
        int[] result = solution.findMaxDistanceReversePairs(arr);
        System.out.println("最长逆序对的位置: [" + result[0] + ", " + result[1] + "]");
    }
}

问：给出一个rand5()，实现一个分布均匀的rand7()生成器？

要实现一个基于 rand5() 的分布均匀的 rand7()，可以利用随机数生成器的组合技术。以下是代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.util.Random;

public class Rand7FromRand5 {

    // Mock implementation of rand5() which generates a random number between 1 and 5 (inclusive)
    public static int rand5() {
        Random random = new Random();
        return random.nextInt(5) + 1; // Generates a number in [1, 5]
    }

    // Implementation of rand7() using rand5()
    public static int rand7() {
        while (true) {
            // Generate a number in [1, 25] using two rand5() calls
            int num = (rand5() - 1) * 5 + rand5();

            // Accept numbers in [1, 21] and discard others
            if (num <= 21) {
                return (num - 1) % 7 + 1; // Map to [1, 7]
            }
        }
    }

    public static void main(String[] args) {
        // Test rand7() function
        int[] counts = new int[7];

        for (int i = 0; i < 1000000; i++) {
            int random = rand7();
            counts[random - 1]++;
        }

        // Print distribution
        for (int i = 0; i < 7; i++) {
            System.out.println((i + 1) + ": " + counts[i]);
        }
    }
}

代码说明：

  1. rand5() 的模拟：
    • 生成一个 1 到 5 的均匀随机数。
  2. 生成 [1, 25] 的均匀随机数：
    • (rand5() - 1) * 5 + rand5() 将两个 rand5() 的结果组合成一个 1 到 25 的随机数。
  3. **限制范围为 [1, 21]**：
    • 舍弃 22 到 25 的值以确保均匀性。21 % 7 == 0，可以完美地映射到 1 到 7。
  4. **映射到 [1, 7]**：
    • (num - 1) % 7 + 1 将 1 到 21 均匀分布的随机数映射到 1 到 7。

输出结果：

  • 程序运行后，将打印每个数字（1 到 7）在 1,000,000 次测试中的出现次数，验证其分布均匀性。

这是实现基于 rand5() 的 rand7() 的常用方法，兼具效率和正确性。

问：实现堆排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import java.util.Arrays;

public class HeapSort {

    // Main method to sort an array using heap sort
    public static void heapSort(int[] arr) {
        int n = arr.length;

        // Build a max heap
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // Extract elements from the heap one by one
        for (int i = n - 1; i > 0; i--) {
            // Move the current root to the end
            swap(arr, 0, i);

            // Call heapify on the reduced heap
            heapify(arr, i, 0);
        }
    }

    // To heapify a subtree rooted at index i
    private static void heapify(int[] arr, int n, int i) {
        int largest = i; // Initialize largest as root
        int left = 2 * i + 1; // Left child index
        int right = 2 * i + 2; // Right child index

        // If the left child is larger than the root
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }

        // If the right child is larger than the largest so far
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }

        // If the largest is not the root
        if (largest != i) {
            swap(arr, i, largest);

            // Recursively heapify the affected subtree
            heapify(arr, n, largest);
        }
    }

    // Utility method to swap two elements in an array
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // Driver method to test the sorting algorithm
    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6, 7};

        System.out.println("Original array: " + Arrays.toString(arr));

        heapSort(arr);

        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

时间复杂度

  1. 构建最大堆：
    构建最大堆的时间复杂度为 O(n)。虽然在最坏情况下堆化的单个操作是 O(log⁡n)，但因为堆化是从底层非叶子节点逐层向上进行的，实际复杂度更低，整体为 O(n)。
  2. 堆排序过程：
    对于每一个元素，将堆顶（最大值）与最后一个元素交换，然后对剩下的 n−1,n−2,…,1个元素重新进行堆化。堆化每次的时间复杂度是 O(log⁡n)，总共需要 n−1 次操作，因此排序过程的时间复杂度为 O(nlog⁡n)。

总时间复杂度：
构建堆和排序过程的复杂度相加，最终为 O(nlog⁡n)O(n \log n)O(nlogn)。

空间复杂度

堆排序是原地排序算法，不需要额外的数组或结构存储中间结果，只使用少量临时变量，空间复杂度为 O(1)O(1)O(1)。

问：给了长度为N的有重复元素的数组，要求输出第10大的数。

以下是解决该问题的 Java 实现代码，使用 优先队列（最小堆） 来高效地找到第 10 大的数，同时总结时间和空间复杂度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.PriorityQueue;

public class Find10thLargest {

    public static int find10thLargest(int[] nums) {
        if (nums == null || nums.length < 10) {
            throw new IllegalArgumentException("Array must have at least 10 elements.");
        }

        // Min-heap to store the top 10 largest elements
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(10);

        for (int num : nums) {
            // Add the number to the heap
            if (minHeap.size() < 10) {
                minHeap.offer(num);
            } else if (num > minHeap.peek()) {
                // Replace the smallest element if the current number is larger
                minHeap.poll();
                minHeap.offer(num);
            }
        }

        // The root of the heap is the 10th largest element
        return minHeap.peek();
    }

    public static void main(String[] args) {
        int[] nums = {3, 2, 1, 5, 6, 4, 10, 9, 7, 8, 15, 14, 12, 11, 13, 20, 19, 18, 17, 16};
        System.out.println("The 10th largest number is: " + find10thLargest(nums));
    }
}

分析

时间复杂度：

  1. 遍历数组需要 O(N)O(N)。
  2. 对于每个元素：
    • 插入或移除堆的时间复杂度为 O(log⁡10)=O(1)O(\log 10) = O(1)。

因此，总时间复杂度为 **O(N)O(N)**。

空间复杂度：

优先队列始终存储最多 10 个元素，空间复杂度为 **O(10)=O(1)O(10) = O(1)**。

问：手写一个对象池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ObjectPool<T> {

    // BlockingQueue to hold pool objects
    private final BlockingQueue<T> pool;
    private final ObjectFactory<T> factory;

    // Constructor to initialize the pool with the given size and factory
    public ObjectPool(int size, ObjectFactory<T> factory) {
        this.pool = new LinkedBlockingQueue<>(size);
        this.factory = factory;

        // Pre-create objects and add them to the pool
        for (int i = 0; i < size; i++) {
            pool.offer(factory.create());
        }
    }

    // Method to borrow an object from the pool
    public T borrowObject() throws InterruptedException {
        return pool.take();
    }

    // Method to return an object back to the pool
    public void returnObject(T obj) {
        if (obj != null) {
            pool.offer(obj);
        }
    }

    // Factory interface for object creation
    public interface ObjectFactory<T> {
        T create();
    }

    // Test
    public static void main(String[] args) {
        // Example: Object pool for StringBuilder objects
        ObjectPool<StringBuilder> stringBuilderPool = new ObjectPool<>(5, StringBuilder::new);

        try {
            // Borrow an object from the pool
            StringBuilder builder = stringBuilderPool.borrowObject();
            builder.append("Hello, Object Pool!");

            // Use the object
            System.out.println(builder.toString());

            // Clear and return the object back to the pool
            builder.setLength(0);
            stringBuilderPool.returnObject(builder);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

分析

功能说明

  1. 对象复用：使用预先分配的对象，避免频繁的对象创建和销毁。
  2. 线程安全：使用 BlockingQueue 保障多线程环境下的安全操作。
  3. 灵活扩展：通过 ObjectFactory 提供自定义对象创建逻辑。

时间复杂度

  • 借用对象：从队列中取对象，时间复杂度为 **O(1)O(1)O(1)**。
  • 归还对象：将对象放回队列，时间复杂度为 **O(1)O(1)O(1)**。

空间复杂度

  • 队列中存储 NNN 个对象，空间复杂度为 **O(N)O(N)O(N)**。
  • 每个对象占用的具体空间取决于其实现。

优点

  • 提高对象使用效率。
  • 减少垃圾回收压力。
  • 灵活扩展，支持多种对象类型。

注意事项

  • 池化对象需要线程安全的初始化和归还操作。
  • 对象池的大小应根据实际场景进行合理配置，过小可能导致等待，过大会占用多余内存。

问：一致性 Hash 算法？其应用场景？

一致性 Hash 算法

一致性 Hash 是一种分布式哈希算法，常用于解决动态扩容、减少数据迁移等问题。该算法的核心思想是将 哈希值 空间组织成一个环形结构，数据和节点（例如缓存服务器）都通过哈希函数映射到这个环上。

核心思想

  1. 环形哈希空间： 哈希值范围设定为 [0,232−1][0, 2^{32}-1]，将其视为一个逻辑上的环形空间。

  2. 节点映射： 每个节点（例如缓存服务器）通过哈希函数映射到环上的某个点。

  3. 数据映射

    ： 数据通过相同的哈希函数映射到环上的某个点。

    • 数据顺时针找到距离最近的节点存储。

  4. 节点变动影响最小

    ：

    • 新增节点：只需重新分配部分环上的数据到新节点。
    • 移除节点：只需将该节点的数据重新分配到其相邻节点。

算法步骤

  1. 使用一个哈希函数

    hashhash

    ，将节点

    NN

    和数据

    KK

    映射到哈希环。

    • 节点位置：hash(N)hash(N)
    • 数据位置：hash(K)hash(K)

  2. 将数据存储到顺时针方向的第一个节点。

  3. 如果节点增删，仅受影响的部分数据需要重新分配，保证迁移量最小。

虚拟节点

为了解决节点分布不均导致的负载不均问题，引入 虚拟节点：

  1. 为每个实际节点生成多个虚拟节点，每个虚拟节点通过不同哈希值映射到环上。
  2. 数据仍按原始规则映射到虚拟节点，再对应到实际节点。

应用场景

  1. 分布式缓存

    ：

    • 常用于 Redis、Memcached 等场景，保证扩容或缩容时数据迁移量最小。

  2. 分布式存储

    ：

    • HDFS、Cassandra 等分布式存储系统用于减少数据分片在节点变动时的迁移。

  3. 负载均衡

    ：

    • 动态调整后端服务器时，尽量保证流量均匀分布。

  4. 分布式任务调度

    ：

    • 将任务动态分配到节点中，任务的节点调整时减少重调度任务数量。

优点

  1. 数据迁移量小： 只影响环上的一小部分数据。
  2. 动态扩展性强： 支持节点动态增删，系统运行时无需停止。
  3. 负载均衡： 配合虚拟节点，提升数据分布均匀性。

缺点

  1. 节点哈希分布不均

    ：

    • 实际节点少时，可能导致负载倾斜问题。
    • 虚拟节点引入后需要增加计算量。

  2. 复杂性

    ：

    • 初期设计复杂度较高。
    • 对哈希函数性能要求高。

示例应用

分布式缓存场景

  1. 系统中有三个缓存节点 N1,N2,N3N1, N2, N3，用户请求数据 K1,K2K1, K2。

  2. 使用一致性 Hash 算法将

    K1,K2K1, K2

    映射到环上：

    • 如果 hash(K1)hash(K1) 落在 N1N1 和 N2N2 之间，数据存储到 N2N2。

  3. 节点增加

    ：

    • 新增节点 N4N4，仅需要将 N3N3 到 N4N4 之间的部分数据迁移。

  4. 节点故障

    ：

    • 如果 N2N2 下线，迁移数据到其相邻节点 N3N3。

这种方式避免了传统取模算法因节点变化导致全量数据迁移的问题，提高了系统可扩展性和高效性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHashing {

    // Hash 环
    private final SortedMap<Integer, String> circle = new TreeMap<>();
    // 虚拟节点数量
    private final int virtualNodeCount;

    public ConsistentHashing(int virtualNodeCount) {
        this.virtualNodeCount = virtualNodeCount;
    }

    // Hash 函数（可以选择更好的哈希函数）
    private int hash(String key) {
        return key.hashCode() & 0x7fffffff; // 转为正数
    }

    // 添加节点
    public void addNode(String node) {
        for (int i = 0; i < virtualNodeCount; i++) {
            int hash = hash(node + "#" + i); // 为每个虚拟节点生成唯一哈希值
            circle.put(hash, node);
        }
    }

    // 移除节点
    public void removeNode(String node) {
        for (int i = 0; i < virtualNodeCount; i++) {
            int hash = hash(node + "#" + i);
            circle.remove(hash);
        }
    }

    // 查找数据存储的节点
    public String getNode(String key) {
        if (circle.isEmpty()) {
            return null;
        }

        int hash = hash(key);
        // 找到第一个大于或等于该哈希值的节点
        SortedMap<Integer, String> tailMap = circle.tailMap(hash);
        int nodeHash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        return circle.get(nodeHash);
    }

    public static void main(String[] args) {
        // 创建一致性哈希环，设置虚拟节点数量为 3
        ConsistentHashing consistentHashing = new ConsistentHashing(3);

        // 添加节点
        consistentHashing.addNode("Node1");
        consistentHashing.addNode("Node2");
        consistentHashing.addNode("Node3");

        // 打印数据分布
        System.out.println("Node for Key 'Data1': " + consistentHashing.getNode("Data1"));
        System.out.println("Node for Key 'Data2': " + consistentHashing.getNode("Data2"));
        System.out.println("Node for Key 'Data3': " + consistentHashing.getNode("Data3"));

        // 添加新节点
        consistentHashing.addNode("Node4");
        System.out.println("After adding Node4:");
        System.out.println("Node for Key 'Data1': " + consistentHashing.getNode("Data1"));
        System.out.println("Node for Key 'Data2': " + consistentHashing.getNode("Data2"));
        System.out.println("Node for Key 'Data3': " + consistentHashing.getNode("Data3"));
    }
}

代码解析

  1. Hash 环的实现：
    • 使用 TreeMap 来存储节点及其对应的哈希值，TreeMap 保证了键的自然顺序。
    • 数据插入时间复杂度为 O(log⁡N)O(\log N)O(logN)，查找时间复杂度为 O(log⁡N)O(\log N)O(logN)。
  2. 虚拟节点：
    • 为每个实际节点生成多个虚拟节点，提升数据分布均匀性。
    • 虚拟节点的数量可调，默认为 3（可以根据实际场景调整）。
  3. 节点查找：
    • 使用 TreeMap.tailMap() 找到顺时针方向第一个大于等于数据哈希值的节点。
    • 如果未找到（哈希值超过最大值），回到环的起点。
  4. 动态扩容与缩容：
    • 动态添加或删除节点时，受影响的仅是部分数据，迁移量小。

时间复杂度

  • 节点插入或删除：O(Mlog⁡N)O(M \log N)O(MlogN)，其中 MMM 是虚拟节点数量，NNN 是总节点数量。
  • 节点查找：O(log⁡N)O(\log N)O(logN)，依赖于 TreeMap 的查找效率。

问：TopK 问题？

问题描述：给定一个包含 N 个元素的数组，找到其中最大的 K 个元素或最小的 K 个元素。

解决方案

  1. 排序法
    • 对数组进行排序后，直接提取最大的 KK 个或最小的 KK 个元素。
    • 时间复杂度：O(Nlog⁡N)
    • 空间复杂度：O(1)（原地排序）
  2. 堆排序（推荐方法）
    • 使用最小堆（找最大 K 个元素）或最大堆（找最小 K 个元素）。
    • 维护一个大小为 K的堆：
      • 如果当前元素比堆顶大，则替换堆顶并重新调整堆。
    • 时间复杂度：O(Nlog⁡K)
      （堆的插入/删除操作的复杂度为 O(log⁡K)，需要操作 N 次）
    • 空间复杂度：O(K)
  3. 快速选择（QuickSelect）
    • 改进的快速排序，利用分治思想，定位到第 K 大的元素位置，不需要对整个数组排序。
    • 时间复杂度：O(N)（平均）
      O(N^2)（最坏情况，当划分极端不均匀时）
    • 空间复杂度：O(1)
  4. 计数排序（适用于整数范围较小的情况）
    • 使用一个计数数组记录每个数字的出现次数。
    • 统计后从大到小输出前 K 个数。
    • 时间复杂度：O(N + R)，R 是整数值的范围。
    • 空间复杂度：O(R)

Java 实现：堆排序法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.PriorityQueue;

public class TopKElements {

    public static int[] findTopK(int[] nums, int k) {
        if (nums == null || k <= 0) {
            return new int[0];
        }

        // 创建一个最小堆
        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); // 插入当前元素
            }
        }

        // 将堆中的元素输出到数组
        int[] result = new int[k];
        int index = 0;
        for (int num : minHeap) {
            result[index++] = num;
        }
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {3, 2, 1, 5, 6, 4, 8, 7};
        int k = 3;
        int[] topK = findTopK(nums, k);

        System.out.println("Top " + k + " elements:");
        for (int num : topK) {
            System.out.print(num + " ");
        }
    }
}

Java 实现：快速选择法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.util.Arrays;

public class TopKQuickSelect {

    public static int[] findTopK(int[] nums, int k) {
        quickSelect(nums, 0, nums.length - 1, nums.length - k);
        return Arrays.copyOfRange(nums, nums.length - k, nums.length);
    }

    private static void quickSelect(int[] nums, int left, int right, int k) {
        if (left >= right) {
            return;
        }
        int pivot = partition(nums, left, right);
        if (pivot == k) {
            return;
        } else if (pivot < k) {
            quickSelect(nums, pivot + 1, right, k);
        } else {
            quickSelect(nums, left, pivot - 1, k);
        }
    }

    private static int partition(int[] nums, int left, int right) {
        int pivot = nums[right];
        int i = left;
        for (int j = left; j < right; j++) {
            if (nums[j] <= pivot) {
                swap(nums, i++, j);
            }
        }
        swap(nums, i, right);
        return i;
    }

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

    public static void main(String[] args) {
        int[] nums = {3, 2, 1, 5, 6, 4, 8, 7};
        int k = 3;
        int[] topK = findTopK(nums, k);

        System.out.println("Top " + k + " elements:");
        for (int num : topK) {
            System.out.print(num + " ");
        }
    }
}

选择合适方法的建议

  • 数据规模小：排序法。
  • 数据规模大，KK 小：堆排序法。
  • 数据无序，且只需一次结果：快速选择法。
  • 数据范围较小：计数排序法。

以上代码分别适用于不同场景，可根据实际需求选择合适的实现方式。

问：试着实现一下LRU算法？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import java.util.Arrays;

public class HeapSort {

    // Main method to sort an array using heap sort
    public static void heapSort(int[] arr) {
        int n = arr.length;

        // Build a max heap
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // Extract elements from the heap one by one
        for (int i = n - 1; i > 0; i--) {
            // Move the current root to the end
            swap(arr, 0, i);

            // Call heapify on the reduced heap
            heapify(arr, i, 0);
        }
    }

    // To heapify a subtree rooted at index i
    private static void heapify(int[] arr, int n, int i) {
        int largest = i; // Initialize largest as root
        int left = 2 * i + 1; // Left child index
        int right = 2 * i + 2; // Right child index

        // If the left child is larger than the root
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }

        // If the right child is larger than the largest so far
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }

        // If the largest is not the root
        if (largest != i) {
            swap(arr, i, largest);

            // Recursively heapify the affected subtree
            heapify(arr, n, largest);
        }
    }

    // Utility method to swap two elements in an array
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // Driver method to test the sorting algorithm
    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6, 7};

        System.out.println("Original array: " + Arrays.toString(arr));

        heapSort(arr);

        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

时间复杂度和空间复杂度

  • 时间复杂度:
    • get: O(1), 因为通过哈希表访问节点和移动节点到头部均为常数时间。
    • put: O(1), 因为更新或添加节点涉及的操作（哈希表和链表）均为常数时间。
  • 空间复杂度:
    • O(C), 其中 C 是缓存的容量，主要用于存储哈希表和链表节点。

问：一个人从起点出发，初始生命值为n，每次可以向前跳k步并消耗k点生命值，路上的每一个位置都有恢复生命值的好蘑菇，和扣除生命值的坏蘑菇，人的生命值不能为0。问该人到达终点时的最大剩余生命值是多少？如果不能到达终点，返回-1。

一开始以为这道题是道动态规划的题目，但是老想不出递推关系式。问了下是不是贪心的思路，面试官说是贪心，然后给了个例子以及一波暗示，我才终于发现其实每次都跳到加血的蘑菇位置就行了。然后赶紧写了波代码，就这样过去了

这道题可以通过动态规划解决，记录每个位置的最大剩余生命值，逐步推算至终点。以下是问题的分解和解法：

解题思路

  1. 定义状态:
    用 dp[i] 表示到达位置 i 时的最大剩余生命值。如果位置 i 不可达，设为负无穷（Integer.MIN_VALUE）。

  2. 状态转移方程:
    从位置 j 跳到位置 i 的条件是 j+k=ij + k = ij+k=i 且 dp[j]−k>0dp[j] - k > 0dp[j]−k>0。
    如果满足，更新:

    dp[i]=max⁡(dp[i],dp[j]−k+蘑菇值[i])dp[i] = \max(dp[i], dp[j] - k + \text{蘑菇值}[i])dp[i]=max(dp[i],dp[j]−k+蘑菇值[i])

  3. 初始化:
    dp[0]=ndp[0] = ndp[0]=n，表示初始生命值为 nnn。

  4. 返回结果:

    • 如果可以到达终点，返回 dp[终点]dp[\text{终点}]dp[终点] 的值。
    • 如果终点不可达，返回 -1。

  5. 优化方向:

    • 可以使用滑动窗口或队列优化来加速跨步检查的过程，避免暴力计算所有可能的跳跃。

Java 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.Arrays;

public class MushroomJump {

    public static int maxLifeRemaining(int[] mushrooms, int n) {
        int length = mushrooms.length;
        int[] dp = new int[length];
        Arrays.fill(dp, Integer.MIN_VALUE); // 初始化为负无穷
        dp[0] = n; // 初始位置生命值
        
        // 遍历每个位置
        for (int i = 1; i < length; i++) {
            for (int k = 1; k <= i; k++) { // 从 i-k 跳到 i
                int prevPos = i - k;
                if (prevPos >= 0 && dp[prevPos] - k > 0) {
                    dp[i] = Math.max(dp[i], dp[prevPos] - k + mushrooms[i]);
                }
            }
        }
        
        // 检查终点生命值
        return dp[length - 1] > 0 ? dp[length - 1] : -1;
    }

    public static void main(String[] args) {
        int[] mushrooms = {0, -2, 3, -5, 2, 4, -3}; // 每个位置的蘑菇值
        int n = 10; // 初始生命值
        System.out.println(maxLifeRemaining(mushrooms, n)); // 输出最大剩余生命值
    }
}

时间复杂度和空间复杂度

  • 时间复杂度:
    O(N^2), 由于对于每个位置 iii，需要检查所有可能跳跃步数 k。
  • 空间复杂度:
    O(N), 仅使用了一个长度为 N 的数组存储中间结果。

优化（滑动窗口法）

在实际应用中，计算 dp[i] 的过程中，我们可以记录上一轮 dp[j]−k 的最大值，从而避免重复计算，时间复杂度可以优化到 O(N)。

这道题可以用贪心的思路来解决，但贪心和动态规划的核心不同：贪心是一种局部最优的策略，而动态规划通过综合考虑所有可能的选择来寻找全局最优解。

贪心思路

  1. 贪心策略:
    在每个位置，我们尽量选择能够使剩余生命值最大的跳跃（即尽量多吃好蘑菇、少扣坏蘑菇）。
    • 在可跳跃的范围内 kkk，选择一个使得 剩余生命值−k+蘑菇值[i]\text{剩余生命值} - k + \text{蘑菇值}[i]剩余生命值−k+蘑菇值[i] 最大的位置 jjj 作为下一步。
    • 如果当前生命值不足以跳到任何下一位置，则直接返回 -1。
  2. 实现过程:
    • 逐步跳跃，记录当前位置生命值。
    • 每次计算可跳跃范围内的最优下一步，更新当前位置和生命值。
    • 如果到达终点，返回最大剩余生命值；否则返回 -1。
  3. 贪心的局限:
    • 贪心不保证全局最优。例如，当某条路需要短期减少生命值但长期收益更高时，贪心可能无法识别这种路径。

贪心实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.PriorityQueue;

public class MushroomJumpGreedy {

    public static int maxLifeRemainingGreedy(int[] mushrooms, int n) {
        int length = mushrooms.length;
        int currentLife = n;
        int position = 0;

        while (position < length - 1) {
            int maxNextLife = Integer.MIN_VALUE;
            int nextPosition = -1;

            // 在当前可跳跃范围内选择最优下一步
            for (int k = 1; k + position < length; k++) {
                int nextPos = position + k;
                int nextLife = currentLife - k + mushrooms[nextPos];

                if (nextLife > 0 && nextLife > maxNextLife) {
                    maxNextLife = nextLife;
                    nextPosition = nextPos;
                }
            }

            // 无法跳到任何位置
            if (nextPosition == -1) {
                return -1;
            }

            // 更新当前位置和生命值
            position = nextPosition;
            currentLife = maxNextLife;
        }

        return currentLife;
    }

    public static void main(String[] args) {
        int[] mushrooms = {0, -2, 3, -5, 2, 4, -3}; // 每个位置的蘑菇值
        int n = 10; // 初始生命值
        System.out.println(maxLifeRemainingGreedy(mushrooms, n)); // 输出最大剩余生命值
    }
}

贪心和动态规划的关系

  • 动态规划的特点:
    动态规划保存了所有可能路径的中间结果，并通过状态转移方程综合考虑，确保全局最优。
  • 贪心和动态规划的对比:
    • 优点: 贪心的时间复杂度更低，通常是 O(N⋅K)O(N \cdot K)O(N⋅K) 或更优。
    • 缺点: 贪心容易漏掉某些可能更优的路径，因为它只考虑了当前最优，而动态规划则可以回溯之前的选择，寻找全局最优解。
  • 适用场景:
    • 如果问题具有贪心选择性质（局部最优解可以导出全局最优解），贪心是理想选择。
    • 如果问题需要对所有路径综合考虑（如复杂的生命值变化或路径选择问题），动态规划更可靠。

贪心在本题的适用性

本题中，贪心能够快速求解，并且在一些情况下可以得到较优解。但如果问题中路径间存在复杂的交叉影响（如短期损失换取长期收益），动态规划更具普适性。

问：leetcode原题，买卖股票。给一组股票价格，只进行一次交易，最大利润是多少？如果可以进行多次交易，利润又是多少呢？

这道题包括两个问题：一次交易和多次交易的最大利润。两种问题分别可以用贪心和动态规划方法解决。

一次交易的最大利润

问题描述

给定一个数组表示股票价格，只能买入和卖出一次，求最大利润。

解题思路

只需找到股票价格的最低点和最高点，并保证最低点在最高点之前。
关键点：从左到右遍历，记录当前的最低价格，然后在每个价格点计算可能的最大利润。

实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class StockProfit {

    // 最大利润，进行一次交易
    public static int maxProfitOneTransaction(int[] prices) {
        if (prices == null || prices.length < 2) {
            return 0;
        }

        int minPrice = Integer.MAX_VALUE;
        int maxProfit = 0;

        for (int price : prices) {
            // 更新最低价格
            minPrice = Math.min(minPrice, price);
            // 计算当前利润，并更新最大利润
            maxProfit = Math.max(maxProfit, price - minPrice);
        }

        return maxProfit;
    }

    public static void main(String[] args) {
        int[] prices = {7, 1, 5, 3, 6, 4};
        System.out.println("Max profit with one transaction: " + maxProfitOneTransaction(prices)); // 输出 5
    }
}

时间复杂度和空间复杂度

  • 时间复杂度：O(N)（只需一次遍历）
  • 空间复杂度：O(1) （只使用常数空间）

多次交易的最大利润

问题描述

可以进行多次交易（但不能同时持有多份股票，必须卖出后再买入），求最大利润。

解题思路

贪心算法：对于每次价格上升（今天的价格比昨天高），累加这段上涨的差值即可。
关键点：股票的每次有效上涨都视为一次交易。

实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class StockProfit {

    // 最大利润，进行多次交易
    public static int maxProfitMultipleTransactions(int[] prices) {
        if (prices == null || prices.length < 2) {
            return 0;
        }

        int maxProfit = 0;

        for (int i = 1; i < prices.length; i++) {
            // 累加每次上涨的差值
            if (prices[i] > prices[i - 1]) {
                maxProfit += prices[i] - prices[i - 1];
            }
        }

        return maxProfit;
    }

    public static void main(String[] args) {
        int[] prices = {7, 1, 5, 3, 6, 4};
        System.out.println("Max profit with multiple transactions: " + maxProfitMultipleTransactions(prices)); // 输出 7
    }
}

时间复杂度和空间复杂度

  • 时间复杂度：O(N) （一次遍历计算所有上涨区间）
  • 空间复杂度：O(1) （只使用常数空间）

总结

  1. 一次交易：
    • 策略：找到最低点和最高点。
    • 时间复杂度：O(N)。
    • 空间复杂度：O(1)。
  2. 多次交易：
    • 策略：累加所有上涨区间的利润。
    • 时间复杂度：O(N)。
    • 空间复杂度：O(1)。

问：有大量已知的url网址，以及一个新的url网址，如何高效的判断新网址是否和已知网址重复？

答：用字典树来做，省略100字。

1. 判断新网址是否和已知网址重复（使用字典树）

思路：

  • 构造一个字典树（Trie），以字符为节点存储所有已知的网址。
  • 判断时，将新的 URL 逐字符遍历，沿字典树查找。如果最终可以完全匹配，则说明重复；否则，将其插入字典树。

字典树的优势：

  • 能够有效判断字符串是否存在，并支持前缀匹配。

实现代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class TrieNode {
    TrieNode[] children = new TrieNode[256]; // 每个字符节点，支持ASCII码
    boolean isEnd = false; // 是否是URL的结尾
}

class UrlTrie {
    private final TrieNode root = new TrieNode();

    // 插入URL
    public void insert(String url) {
        TrieNode node = root;
        for (char ch : url.toCharArray()) {
            int index = ch; // ASCII值作为索引
            if (node.children[index] == null) {
                node.children[index] = new TrieNode();
            }
            node = node.children[index];
        }
        node.isEnd = true;
    }

    // 判断是否存在URL
    public boolean search(String url) {
        TrieNode node = root;
        for (char ch : url.toCharArray()) {
            int index = ch;
            if (node.children[index] == null) {
                return false;
            }
            node = node.children[index];
        }
        return node.isEnd;
    }
}

public class UrlChecker {
    public static void main(String[] args) {
        UrlTrie trie = new UrlTrie();
        trie.insert("http://example.com");
        trie.insert("https://openai.com");

        System.out.println(trie.search("http://example.com")); // 输出 true
        System.out.println(trie.search("http://google.com")); // 输出 false
    }
}

时间复杂度：

  • 插入/查找：O(L)O(L)，LL 是 URL 的长度。

空间复杂度：

  • O(N×L)O(N \times L)，NN 是 URL 数量，LL 是 URL 的平均长度。

总结：字典树：

  • 优点：支持前缀查询，适合需要前缀匹配的场景。
  • 缺点：空间占用大。
  • 复杂度：时间 O(L)O(L)，空间 O(N×L)O(N \times L)。

问：url很长，字典树很占空间怎么办？

答：对url进行分段哈希，然后再放到树节点中，而不是直接把每一个字符作为一个树节点。

2. 字典树占用空间优化（分段哈希）

思路：

  • 对于 URL 较长的情况，使用分段哈希存储。
  • 将 URL 分为固定长度的片段，每个片段计算哈希值，将哈希值存入哈希表，而非存储完整字符。

优点：

  • 减少字典树节点数量，降低空间占用。
  • 哈希值替代字符存储，相对高效。

实现代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.HashMap;

class SegmentHash {
    private final HashMap<Integer, Boolean> hashMap = new HashMap<>();
    private static final int SEGMENT_LENGTH = 10;

    // 计算哈希
    private int computeHash(String segment) {
        return segment.hashCode(); // 使用 Java 默认的哈希函数
    }

    // 插入URL
    public void insert(String url) {
        for (int i = 0; i < url.length(); i += SEGMENT_LENGTH) {
            int end = Math.min(i + SEGMENT_LENGTH, url.length());
            String segment = url.substring(i, end);
            hashMap.put(computeHash(segment), true);
        }
    }

    // 判断是否存在URL
    public boolean search(String url) {
        for (int i = 0; i < url.length(); i += SEGMENT_LENGTH) {
            int end = Math.min(i + SEGMENT_LENGTH, url.length());
            String segment = url.substring(i, end);
            if (!hashMap.containsKey(computeHash(segment))) {
                return false;
            }
        }
        return true;
    }
}

public class UrlChecker {
    public static void main(String[] args) {
        SegmentHash hashChecker = new SegmentHash();
        hashChecker.insert("http://example.com");
        hashChecker.insert("https://openai.com");

        System.out.println(hashChecker.search("http://example.com")); // 输出 true
        System.out.println(hashChecker.search("http://google.com")); // 输出 false
    }
}

时间复杂度：

  • 插入/查找：O(L/k)O(L / k)，kk 是分段长度。

空间复杂度：

  • O(N×L/k)O(N \times L / k)，降低了存储开销。

分段哈希：

  • 优点：显著降低空间开销。
  • 缺点：实现相对复杂。
  • 复杂度：时间 O(L/k)，空间 O(N×L/k)。

问：你刚才提到了哈希，那说一下哈希的实现？

3. 使用哈希实现快速判断

思路：

  • 将每个 URL 使用哈希函数计算出固定的哈希值，存入哈希表。
  • 查找时直接查哈希表。

优缺点：

  • 优点：查找速度快，空间占用小。
  • 缺点：可能存在哈希冲突，需要解决冲突问题。

实现代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.HashSet;

public class UrlHashChecker {
    private final HashSet<Integer> urlHashes = new HashSet<>();

    // 插入URL
    public void insert(String url) {
        urlHashes.add(url.hashCode());
    }

    // 判断是否存在URL
    public boolean search(String url) {
        return urlHashes.contains(url.hashCode());
    }

    public static void main(String[] args) {
        UrlHashChecker hashChecker = new UrlHashChecker();
        hashChecker.insert("http://example.com");
        hashChecker.insert("https://openai.com");

        System.out.println(hashChecker.search("http://example.com")); // 输出 true
        System.out.println(hashChecker.search("http://google.com")); // 输出 false
    }
}

时间复杂度：

  • 插入/查找：O(1)O(1)。

空间复杂度：

  • O(N)O(N)，存储每个 URL 的哈希值。

全哈希：

  • 优点：查找速度最快，空间占用最小。
  • 缺点：不支持前缀匹配，可能有哈希冲突。
  • 复杂度：时间 O(1)O(1)，空间 O(N)O(N)。

答：说了下STL里面unordered_map的大概实现原理，哈希函数，二次探测，开链，省略100字。

以下是关于 HashMap 和类似于 unordered_map 的实现原理及相关扩容、哈希机制的解释，针对 Java：

1. Java 中 HashMap 的实现原理

  • 底层结构：HashMap 是基于哈希表实现的，内部使用一个数组，每个数组元素是一个链表（JDK 1.8 之前）或红黑树（JDK 1.8 及之后）。

  • 哈希函数：通过 key.hashCode() 计算键的哈希值，然后通过取模或按位操作计算数组索引： index=hashCode(key)&(table.length−1)\text{index} = \text{hashCode(key)} & (\text{table.length} - 1) 这里使用 & 而非 % 提高效率。

  • 冲突解决：使用

    开链法

    （链表或红黑树）解决哈希冲突。

    • JDK 1.8 引入了红黑树，当单个桶的链表长度超过 8 时，会转化为红黑树，提高查询效率。

2. 扩容机制

扩容的触发条件

  1. 负载因子（Load Factor）： load factor=元素个数 / 桶的数量。默认负载因子为 0.75。
  2. 当元素数量超过 (桶的数量×负载因子)时，触发扩容。

扩容的具体过程

  1. 容量翻倍：将桶的数量扩容为原来的 2 倍。
  2. 重新哈希：
    • 因为桶数量变化，元素的索引会受到影响，需要重新分配每个元素的位置。
    • 在 JDK 1.8 中，利用二进制特性优化了重新哈希的过程，判断是否需要移动到新的桶位置。

为什么扩容倍数是 2？

  1. 效率：哈希值按位与操作适合二进制结构，翻倍扩容仅需判断哈希值的高位。
  2. 均匀分布：新的桶数量可以更均匀地分配元素。
  3. 性能与内存的平衡：翻倍扩容在性能和内存浪费之间取得了较好的权衡。

3. 哈希冲突解决

开链法（Separate Chaining）

  1. 每个桶存储一个链表或红黑树。
  2. 如果多个键映射到同一个桶，通过链表（或树）的形式存储冲突的元素。
  3. 查询时需要遍历链表（或树）查找目标键。

红黑树

  • 当单个桶的链表长度超过 8 时，链表转化为红黑树，时间复杂度由 O(n) 降低到 O(log⁡n)。

4. Java 哈希函数实现

Java 默认使用对象的 hashCode() 方法生成哈希值，可以通过重写 hashCode 和 equals 方法自定义键的比较逻辑。

5. 二次探测与开放地址法

Java 的 HashMap 使用开链法解决冲突，未采用二次探测或开放地址法，因为：

  • 开链法在动态扩容时更高效。
  • 开链法的分布均匀性和性能在大多数场景下优于开放地址法。

6. 示例代码：自定义简单的 HashMap

以下是一个简单的 HashMap 实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import java.util.LinkedList;

public class SimpleHashMap<K, V> {
    private static final int INITIAL_CAPACITY = 16;
    private static final float LOAD_FACTOR = 0.75f;
    private LinkedList<Node<K, V>>[] table;
    private int size = 0;

    static class Node<K, V> {
        final K key;
        V value;

        Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }

    public SimpleHashMap() {
        table = new LinkedList[INITIAL_CAPACITY];
    }

    public void put(K key, V value) {
        int index = getIndex(key);
        if (table[index] == null) {
            table[index] = new LinkedList<>();
        }

        for (Node<K, V> node : table[index]) {
            if (node.key.equals(key)) {
                node.value = value;
                return;
            }
        }

        table[index].add(new Node<>(key, value));
        size++;

        if ((float) size / table.length > LOAD_FACTOR) {
            resize();
        }
    }

    public V get(K key) {
        int index = getIndex(key);
        if (table[index] != null) {
            for (Node<K, V> node : table[index]) {
                if (node.key.equals(key)) {
                    return node.value;
                }
            }
        }
        return null;
    }

    private int getIndex(K key) {
        return key.hashCode() & (table.length - 1);
    }

    private void resize() {
        LinkedList<Node<K, V>>[] oldTable = table;
        table = new LinkedList[table.length * 2];
        size = 0;

        for (LinkedList<Node<K, V>> bucket : oldTable) {
            if (bucket != null) {
                for (Node<K, V> node : bucket) {
                    put(node.key, node.value);
                }
            }
        }
    }

    public static void main(String[] args) {
        SimpleHashMap<String, Integer> map = new SimpleHashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("cherry", 3);

        System.out.println(map.get("apple"));  // Output: 1
        System.out.println(map.get("banana")); // Output: 2
        System.out.println(map.get("cherry")); // Output: 3
    }
}

7. 小结

  • HashMap 是基于哈希表实现，使用开链法解决冲突。
  • 扩容时桶数量翻倍，重新计算所有元素的哈希索引。
  • 默认负载因子为 0.75，适合大多数场景。
  • 哈希函数可以自定义，以提高冲突解决效率。

问：哈希在什么情况下需要扩容？怎么扩容？

答：说了下饱和度过大时需要扩容，每次容量翻一倍。

问：为什么扩容时是翻一倍呢？而不是两倍，三倍？

答：（这我就真不知道了😖，一顿乱猜）于是说了下STL内存分配器的特点以及里面内存池的结构可能更适合这样分配，才算糊弄过去😅。

问：服务器中有大量数据需要迁移，如何在不停止对外服务的情况下安全的迁移数据？

答：一开始没明白意思，说这个直接复制就行噻😃，

在不停止对外服务的情况下迁移大量数据是一项复杂的任务，需要考虑数据一致性、服务可用性、性能影响等问题。以下是一个通用的迁移方案：

1. 问题分析

  • 数据一致性：迁移过程中，源和目标数据库可能出现数据不一致的问题。
  • 服务可用性：对外服务需要保持可用，迁移操作不能阻塞读写请求。
  • 性能影响：迁移操作可能对现有服务性能造成影响，需要最小化对生产环境的冲击。

2. 数据迁移的基本流程

阶段 1：准备阶段

  1. 评估数据量与系统性能：
    • 确定迁移数据的总量。
    • 评估现有系统的负载能力，合理规划迁移速度。
  2. 目标数据库初始化：
    • 在目标服务器上创建与源数据库相同的结构（表、索引、存储过程等）。
  3. 工具选择：
    • 使用成熟的迁移工具，例如 DataX、Canal、AWS DMS 等。
    • 或者开发自定义迁移脚本。
  4. 日志与监控：
    • 设置迁移的日志记录和监控机制，跟踪迁移进度和错误。

阶段 2：数据迁移阶段

  1. 全量迁移：

    • 先进行一次数据的全量拷贝。

    • 使用批量操作减少对服务的影响（例如分页批量处理，每次迁移一定数量的记录）。

    • 示例代码（伪代码）：

      1
      2
      3
      4
      5
      6
      int batchSize = 1000;
      for (int offset = 0; ; offset += batchSize) {
          List<Data> batch = sourceDb.fetchData(offset, batchSize);
          if (batch.isEmpty()) break;
          targetDb.insertData(batch);
      }

  2. 增量同步：

    • 使用 CDC（Change Data Capture） 工具或机制捕获源数据库中的增量变化。
    • 将新增、更新、删除操作实时同步到目标数据库。
    • 常见工具：
      • Canal：解析 MySQL 的 binlog。
      • Debezium：支持 MySQL、PostgreSQL 等多种数据库的增量数据捕获。

阶段 3：切换与验证

  1. 灰度切换：
    • 部署一部分流量到目标数据库，验证其是否工作正常。
    • 如果发现问题，可以回滚到源数据库。
  2. 一致性校验：
    • 对比源数据库与目标数据库的数据一致性。
    • 常见方法：
      • 行数校验：检查记录总数是否一致。
      • 抽样校验：随机抽取数据并对比。
      • 全量校验：对比每条记录的内容（适合小数据集或离线校验）。
  3. 最终切换：
    • 将所有读写流量切换到目标数据库。
    • 停止源数据库的写操作。

3. 技术细节与优化

  1. 分批迁移：
    • 按主键范围或时间分片进行迁移，减少对单次查询的压力。
  2. 流量限速：
    • 为迁移任务设置限速，防止占用过多资源影响线上服务。
    • 示例：通过令牌桶算法控制迁移速率。
  3. 数据校验工具：
    • 使用工具如 DataDiff 对数据一致性进行快速对比。

4. 常见问题及应对

  1. 迁移过程中写操作频繁：
    • 使用双写机制：写操作同时写入源和目标数据库。
    • 或者延迟迁移较活跃的表。
  2. 迁移工具性能不足：
    • 通过并发批量迁移提高效率。
  3. 目标数据库性能瓶颈：
    • 增加目标数据库的硬件资源。
    • 暂时关闭目标数据库的非必要索引，提高写入速度。

5. 总结

  • 全量迁移 + 增量同步 是数据迁移的标准流程。
  • CDC 工具 是解决增量同步的关键，推荐使用成熟工具。
  • 在迁移过程中，保持服务的可用性和数据的一致性是首要目标。
  • 完整迁移流程需要严格验证，确保切换后业务无影响。

问：然后面试官提醒要是数据迁移的过程中数据被改动了怎么办？

答：需要对数据加锁。

数据迁移过程中数据被改动是一个常见的风险，尤其是在需要保持服务可用的情况下。要解决这个问题，通常需要结合 增量同步 和 一致性校验 来确保数据迁移的正确性和完整性。以下是详细的应对方案：

1. 问题分析

在迁移过程中，数据被改动可能导致：

  • 目标数据库与源数据库不一致。
  • 部分数据丢失或覆盖。
  • 切换后查询结果异常。

可能的改动原因包括：

  • 数据在迁移过程中被更新、删除或新增。
  • 并发写入导致迁移的部分数据过时。

2. 解决方案

为了解决迁移过程中数据被改动的问题，可以采取以下措施：

(1) 增量同步

增量同步是保证数据一致性的关键步骤。

  • Change Data Capture（CDC）：

    • 捕获源数据库的实时变更（新增、修改、删除）。
    • 通过工具（如 Canal、Debezium）解析数据库的变更日志（如 MySQL binlog）。
    • 将变更同步到目标数据库，保证目标数据库实时更新。

    示例（使用 Canal 捕获增量变更）：

    1
    2
    3
    4
    5
    // Pseudo-code for capturing and applying changes
    while (true) {
        List<ChangeLog> changes = fetchChangeLogsFromSource();
        applyChangesToTarget(changes);
    }

  • 双写机制：

    • 在迁移过程中，所有写操作同时写入源数据库和目标数据库。
    • 缺点：增加了业务代码复杂性。

(2) 数据校验

在迁移完成后进行数据一致性校验，确保数据没有因改动产生差异。

  • 行数校验：

    • 对比源和目标表的记录总数。

    • SQL 示例：

      1
      2
      SELECT COUNT(*) FROM source_table;
      SELECT COUNT(*) FROM target_table;

  • 内容校验：

    • 对比每条记录的字段内容，适合小数据量或分片抽样。

    • 示例（基于主键范围的校验）：

      1
      2
      SELECT * FROM source_table WHERE id BETWEEN 1 AND 1000;
      SELECT * FROM target_table WHERE id BETWEEN 1 AND 1000;

  • Hash 校验：

    • 为表生成全量或分片的哈希值，快速对比一致性。

    • 示例：

      1
      2
      SELECT MD5(GROUP_CONCAT(field1, field2)) FROM source_table;
      SELECT MD5(GROUP_CONCAT(field1, field2)) FROM target_table;

(3) 延迟切换

延迟切换允许源和目标数据库同时工作一段时间，确保增量同步完成。

  • 在完成全量迁移后，源数据库仍接受写入，同时记录所有变更。
  • 等到目标数据库的增量同步完全跟上后，再切换流量到目标数据库。

3. 防范改动的策略

(1) 数据库锁定

在全量迁移时，为减少数据改动，考虑对源数据库加锁（仅限业务低峰时段）。

  • 缺点：锁定会影响业务写入操作，不适用于高可用场景。

(2) 分片迁移

将数据按分片（如主键范围或时间）逐步迁移，避免长时间占用资源，同时减少因并发写入导致的改动。

  • 增量同步的压力也会降低。

(3) 增量补偿

在迁移完成后，通过再次增量同步捕获遗漏的改动数据，确保最终一致性。

4. 实现流程

以下是结合增量同步和校验的完整迁移流程：

  1. 全量迁移：逐步迁移数据，并记录迁移时间点。
  2. 增量捕获：通过 CDC 工具捕获从迁移时间点之后的数据改动。
  3. 应用变更：将捕获的增量数据实时同步到目标数据库。
  4. 一致性校验：对比源和目标数据库，确保无数据差异。
  5. 切换流量：确认一致后，将业务流量切换到目标数据库。
  6. 观察回滚：切换后继续监控一段时间，如果出现问题，可以快速切换回源数据库。

5. 总结

迁移过程中数据改动的问题可以通过以下方式解决：

  • 增量同步：通过 CDC 工具捕获和同步实时变更。
  • 双写机制：同时写入源和目标数据库，确保一致性。
  • 数据校验：迁移完成后，通过行数、内容或哈希值校验验证一致性。
  • 延迟切换：在源和目标数据库并行运行一段时间，确保所有数据完全同步。

这种方案兼顾了服务可用性和数据一致性，适合生产环境中的无缝迁移需求。

问：加锁了不就没法对外服务了吗？

答：可以把数据分成许多段，复制某一段的时候就把这一段数据加锁。

问：找出数组中只出现一次的那个数，其他都出现两次；(异或) 接上面，如果数组中有两个数只出现一次呢？

问题分析

这两个问题可以用 位运算 的技巧解决。异或运算的特性是：

  1. 相同的数异或结果为 0。
  2. 任意数与 0 异或，结果为该数本身。
  3. 异或满足交换律和结合律。

第一问：数组中只有一个数出现一次，其他数都出现两次

思路:
遍历数组，将所有元素进行异或运算，最终的结果就是只出现一次的那个数。因为成对出现的数会互相抵消。

时间复杂度:

  • 时间复杂度：O(N) （遍历一次数组）
  • 空间复杂度：O(1) （仅使用常量空间）

代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SingleNumber {
    public static int findSingleNumber(int[] nums) {
        int result = 0;
        for (int num : nums) {
            result ^= num;
        }
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {2, 3, 2, 4, 3};
        System.out.println("Single number: " + findSingleNumber(nums)); // Output: 4
    }
}

第二问：数组中有两个数只出现一次，其他数都出现两次

思路:

  1. 如果数组中有两个只出现一次的数，则最终的异或结果为 x ^ y（x 和 y 是这两个数），其值不为 0。

  2. 找到 

    1
    x ^ y

    结果中任意为 

    1
    1

    的位（例如最低位的 

    1
    1

    ），通过这一位将数组分成两组：

    • 一组中，该位为 1。
    • 另一组中，该位为 0。

  3. 这样，两个只出现一次的数会分别落在两个组中，而每组中的其他数都会因为两两相同被抵消。

  4. 对每组分别异或即可得到结果。

时间复杂度:

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class SingleNumbers {
    public static int[] findTwoSingleNumbers(int[] nums) {
        // Step 1: XOR all numbers to get x ^ y
        int xor = 0;
        for (int num : nums) {
            xor ^= num;
        }

        // Step 2: Find the rightmost set bit in xor (bit where x and y differ)
        int diff = xor & (-xor);

        // Step 3: Divide numbers into two groups and XOR separately
        int x = 0, y = 0;
        for (int num : nums) {
            if ((num & diff) == 0) {
                x ^= num; // Group where the bit is 0
            } else {
                y ^= num; // Group where the bit is 1
            }
        }

        return new int[]{x, y};
    }

    public static void main(String[] args) {
        int[] nums = {2, 4, 6, 2, 3, 5, 6, 3};
        int[] result = findTwoSingleNumbers(nums);
        System.out.println("Two single numbers: " + result[0] + " and " + result[1]); // Output: 4 and 5
    }
}

总结

  1. 单个数出现一次: 使用异或直接找出。
  2. 两个数出现一次: 使用异或将问题分组后分别找出。

这两种方法都充分利用了异或运算的特性，具有线性时间复杂度和常量空间复杂度，适合处理大数据量的场景。

问：BST中任意两个节点差的最小值

问题分析

在二叉搜索树（BST）中，任意两个节点的差最小值实际上是两个相邻节点的差值最小。因为 BST 的中序遍历是有序的，所以可以通过中序遍历得到所有节点值的有序数组，再计算相邻节点的差值即可。

算法思路

  1. 中序遍历: 利用 BST 的性质，通过中序遍历得到有序的节点值。
  2. 计算最小差值: 遍历有序数组，计算每两个相邻节点值的差，记录最小值。

时间和空间复杂度

  • 时间复杂度: O(N)，其中 NN 是节点数，因为需要遍历一次树。
  • 空间复杂度: O(H)，其中 HH 是树的高度，用于递归栈或存储中序遍历的结果。如果递归实现中序遍历，栈空间与树高度成正比。

方法 1：中序遍历存储所有节点值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.ArrayList;
import java.util.List;

public class MinDiffInBST {
    public static int minDiffInBST(TreeNode root) {
        List<Integer> values = new ArrayList<>();
        // Step 1: In-order traversal to get sorted values
        inOrder(root, values);

        // Step 2: Find minimum difference between adjacent values
        int minDiff = Integer.MAX_VALUE;
        for (int i = 1; i < values.size(); i++) {
            minDiff = Math.min(minDiff, values.get(i) - values.get(i - 1));
        }
        return minDiff;
    }

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

    public static void main(String[] args) {
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(6);
        root.left.left = new TreeNode(1);
        root.left.right = new TreeNode(3);

        System.out.println("Minimum Difference: " + minDiffInBST(root)); // Output: 1
    }
}

class TreeNode {
    int val;
    TreeNode left, right;

    TreeNode(int val) {
        this.val = val;
    }
}

方法 2：中序遍历时即时计算最小差值（无需存储数组）

通过中序遍历的过程中直接比较当前节点与前一个节点的值，更新最小差值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class MinDiffInBSTOptimized {
    private static Integer prev = null;
    private static int minDiff = Integer.MAX_VALUE;

    public static int minDiffInBST(TreeNode root) {
        prev = null; // Reset the previous node
        minDiff = Integer.MAX_VALUE; // Reset the minimum difference
        inOrder(root);
        return minDiff;
    }

    private static void inOrder(TreeNode node) {
        if (node == null) return;

        // Traverse left subtree
        inOrder(node.left);

        // Process current node
        if (prev != null) {
            minDiff = Math.min(minDiff, node.val - prev);
        }
        prev = node.val;

        // Traverse right subtree
        inOrder(node.right);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(6);
        root.left.left = new TreeNode(1);
        root.left.right = new TreeNode(3);

        System.out.println("Minimum Difference: " + minDiffInBST(root)); // Output: 1
    }
}

class TreeNode {
    int val;
    TreeNode left, right;

    TreeNode(int val) {
        this.val = val;
    }
}

比较两种方法

  1. 方法 1:
    • 中序遍历存储所有节点值。
    • 优点：实现简单，清晰易懂。
    • 缺点：需要额外空间存储节点值。
  2. 方法 2:
    • 中序遍历时直接计算，节省空间。
    • 优点：空间复杂度低，仅用常量空间存储 prev 和 minDiff。

在空间受限的情况下，推荐 方法 2。

问：判断二叉树是否中心对称

问题分析

判断一棵二叉树是否中心对称，即从根节点向左和向右展开的子树在结构和节点值上对称。

算法思路

  1. 递归方法:
    • 如果根节点为空，树是对称的。
    • 如果只有一个子树为空或者两个子树的值不同，树不对称。
    • 递归比较左子树的左子树与右子树的右子树、左子树的右子树与右子树的左子树。
    • 时间复杂度 O(N)O(N)，空间复杂度 O(H)O(H)（递归栈高度）。
  2. 迭代方法:
    • 使用队列保存成对的节点。
    • 每次从队列取出两两节点比较，若不同则不对称。
    • 时间复杂度 O(N)O(N)，空间复杂度 O(N)O(N)。

方法 1：递归实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class SymmetricTree {
    public static boolean isSymmetric(TreeNode root) {
        if (root == null) return true;
        return isMirror(root.left, root.right);
    }

    private static boolean isMirror(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null) return true;
        if (t1 == null || t2 == null) return false;
        return (t1.val == t2.val) 
                && isMirror(t1.left, t2.right) 
                && isMirror(t1.right, t2.left);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(2);
        root.left.left = new TreeNode(3);
        root.left.right = new TreeNode(4);
        root.right.left = new TreeNode(4);
        root.right.right = new TreeNode(3);

        System.out.println("Is symmetric: " + isSymmetric(root)); // Output: true
    }
}

class TreeNode {
    int val;
    TreeNode left, right;

    TreeNode(int val) {
        this.val = val;
    }
}

方法 2：迭代实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.LinkedList;
import java.util.Queue;

public class SymmetricTreeIterative {
    public static boolean isSymmetric(TreeNode root) {
        if (root == null) return true;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root.left);
        queue.add(root.right);

        while (!queue.isEmpty()) {
            TreeNode t1 = queue.poll();
            TreeNode t2 = queue.poll();

            if (t1 == null && t2 == null) continue;
            if (t1 == null || t2 == null || t1.val != t2.val) return false;

            queue.add(t1.left);
            queue.add(t2.right);
            queue.add(t1.right);
            queue.add(t2.left);
        }
        return true;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(2);
        root.left.left = new TreeNode(3);
        root.left.right = new TreeNode(4);
        root.right.left = new TreeNode(4);
        root.right.right = new TreeNode(3);

        System.out.println("Is symmetric: " + isSymmetric(root)); // Output: true
    }
}

class TreeNode {
    int val;
    TreeNode left, right;

    TreeNode(int val) {
        this.val = val;
    }
}

复杂度分析

递归方法

  • 时间复杂度: O(N)O(N)，需要访问所有节点。
  • 空间复杂度: O(H)O(H)，递归栈的高度，最坏情况下 H=NH = N（链式树）。

迭代方法

  • 时间复杂度: O(N)O(N)，需要访问所有节点。
  • 空间复杂度: O(N)O(N)，队列最多保存 N/2N/2 个节点。

测试用例

  1. 空树：root = null，输出 true。
  2. 单节点树：root = [1]，输出 true。
  3. 对称树：root = [1, 2, 2, 3, 4, 4, 3]，输出 true。
  4. 非对称树：root = [1, 2, 2, null, 3, null, 3]，输出 false。

两种方法都可以正确判断二叉树是否对称，选择哪种方法视具体需求和限制而定。

问：大数相乘

问题分析

大数相乘指的是当两个数字非常大（超出语言的原生整数范围）时，需要用字符串或数组来模拟实现乘法运算。

算法思路

基本思路

  1. 倒序处理: 将两个数字从低位到高位逐位相乘。
  2. 按位累加: 模拟竖式乘法，将每次的结果累加到对应的位置。
  3. 进位处理: 如果某位的值超过 10，则进位到下一位。

步骤

  1. 将两个大数字符串反转，方便从低位开始逐位相乘。
  2. 使用一个数组保存每个位的乘积结果。
  3. 遍历两个数字的每一位，计算乘积并存储到结果数组中对应的位置。
  4. 对数组进行进位处理。
  5. 将结果数组转为字符串并去掉前导零。

Java 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class BigNumberMultiply {

    public static String multiply(String num1, String num2) {
        if (num1.equals("0") || num2.equals("0")) return "0";

        int n = num1.length(), m = num2.length();
        int[] result = new int[n + m]; // 保存乘积结果的数组

        // 从低位到高位逐位相乘
        for (int i = n - 1; i >= 0; i--) {
            for (int j = m - 1; j >= 0; j--) {
                int mul = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
                int sum = mul + result[i + j + 1]; // 当前乘积加上已有值

                result[i + j + 1] = sum % 10; // 保存当前位
                result[i + j] += sum / 10;   // 处理进位
            }
        }

        // 将结果数组转为字符串
        StringBuilder sb = new StringBuilder();
        for (int num : result) {
            if (!(sb.length() == 0 && num == 0)) { // 去掉前导零
                sb.append(num);
            }
        }

        return sb.toString();
    }

    public static void main(String[] args) {
        String num1 = "123456789";
        String num2 = "987654321";

        System.out.println("Product: " + multiply(num1, num2));
    }
}

复杂度分析

时间复杂度

  • 内层嵌套循环需要遍历 O(N×M)O(N \times M)，其中 NN 和 MM 分别为两个数字的长度。

空间复杂度

  • 结果数组需要 O(N+M)O(N + M) 的空间来存储中间结果。

测试用例

输入

  1. num1=”123”,num2=”456”num1 = “123”, num2 = “456”
  2. num1=”0”,num2=”12345”num1 = “0”, num2 = “12345”
  3. num1=”999999”,num2=”999999”num1 = “999999”, num2 = “999999”

输出

  1. 输出："56088"
  2. 输出："0"
  3. 输出："999998000001"

扩展

可以进一步优化：

  1. 高效字符串处理: 在字符串拼接时减少不必要的操作。
  2. FFT 优化: 使用快速傅里叶变换（FFT）处理非常长的大数乘法。

这个实现适用于一般大数场景，高效且易读。

问：给我一张纸，画了一个九方格，都填了数字，给一个MN矩阵，从1开始逆时针打印这MN个数，要求时间复杂度尽可能低，可以先说下思路

问题分析

输入

  1. 一个 M×NM \times N 的矩阵，表示一个九方格或更大的矩阵。
  2. 打印顺序从左上角的数字 11 开始，按照 逆时针方向。

输出

  • 打印按逆时针顺序排列的矩阵元素。

逆时针遍历的思路

  1. 层级遍历

    ：

    • 矩阵可看作由若干层组成，每层是矩阵的外圈。
    • 每遍历一层，就收缩矩阵的边界。

  2. 访问顺序

    ：

    • 每一层按逆时针顺序依次访问：左 -> 下 -> 右 -> 上。

  3. 控制边界

    ：

    • 使用四个变量 top, bottom, left, right 来表示当前未遍历的边界。
    • 每遍历一圈后，更新这些变量。

实现步骤

  1. 初始化边界：top = 0, bottom = M-1, left = 0, right = N-1。
  2. 循环遍历：
    • 从 top 到 bottom 打印左侧边界；
    • 从 left 到 right 打印底部边界；
    • 从 bottom 到 top 打印右侧边界；
    • 从 right 到 left 打印顶部边界。
  3. 在每次遍历后，缩小矩阵的边界，直到所有元素被打印。

时间复杂度

  • 每个元素只访问一次，因此时间复杂度为 O(M×N)O(M \times N)。

空间复杂度

  • 只需要常量空间存储边界和索引变量，空间复杂度为 O(1)O(1)。

接下来可以用 Java 来实现这个算法，确保效率与正确性。是否直接提供代码？

问：数组A，2*n个元素，n个奇数、n个偶数，设计一个算法，使得数组奇数下标位置放置的都是奇数，偶数下标位置放置的都是偶数。先说下你的思路

问题分析

输入

  • 一个数组

    AA

    ，包含

    2n2n

    个整数，其中：

    • nn 个奇数
    • nn 个偶数

输出

  • 数组重新排列后满足：
    • 奇数下标（0, 2, 4, …）的位置都放奇数；
    • 偶数下标（1, 3, 5, …）的位置都放偶数。

思路分析

  1. 数组中奇数和偶数的数量相等，最终必然有奇数放在奇数下标，偶数放在偶数下标。
  2. 只需要检查每个位置的元素是否符合规则，不符合则交换即可。

详细步骤

  1. 定义两个指针

    ：

    • oddIndex: 指向当前不正确放置奇数的位置（从下标 0 开始）。
    • evenIndex: 指向当前不正确放置偶数的位置（从下标 1 开始）。

  2. 遍历数组

    ：

    • 遍历数组中的所有元素：

      • 如果 

        1
        oddIndex

        指向的不是奇数：

        • 找到最近的偶数索引 evenIndex，并交换两者；
        • 更新 oddIndex 和 evenIndex。

      • 如果 

        1
        evenIndex

        指向的不是偶数：

        • 找到最近的奇数索引 oddIndex，并交换两者；
        • 更新 evenIndex 和 oddIndex。

  3. 完成遍历

    ：

    • 当所有索引都符合条件时，数组已排列完成。

时间复杂度

  • 遍历数组：每个元素访问一次 O(2n)=O(n)O(2n) = O(n)。
  • 交换操作：交换的次数最多是数组的一半 O(n/2)=O(n)O(n/2) = O(n)。

总时间复杂度：O(n)O(n)

空间复杂度

  • 只需要常量空间存储两个指针，空间复杂度为 O(1)O(1)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class ArrayRearrange {
    
    public static void rearrangeArray(int[] arr) {
        int n = arr.length / 2; // 假设数组长度为 2n
        
        int oddIndex = 0;  // 奇数下标位置
        int evenIndex = 1; // 偶数下标位置
        
        while (oddIndex < arr.length && evenIndex < arr.length) {
            // 找到一个不符合规则的奇数位置
            while (oddIndex < arr.length && arr[oddIndex] % 2 == 1) {
                oddIndex += 2; // 跳过已经放置好的奇数
            }
            
            // 找到一个不符合规则的偶数位置
            while (evenIndex < arr.length && arr[evenIndex] % 2 == 0) {
                evenIndex += 2; // 跳过已经放置好的偶数
            }
            
            // 如果奇数位置的元素是偶数，偶数位置的元素是奇数
            // 则交换两者
            if (oddIndex < arr.length && evenIndex < arr.length) {
                // 交换奇数和偶数
                int temp = arr[oddIndex];
                arr[oddIndex] = arr[evenIndex];
                arr[evenIndex] = temp;
            }
        }
    }
    
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
        
        System.out.println("Original Array:");
        printArray(arr);
        
        rearrangeArray(arr);
        
        System.out.println("Rearranged Array:");
        printArray(arr);
    }
}

代码说明

  1. rearrangeArray(int[] arr):
    • 通过两个指针 oddIndex 和 evenIndex 来遍历数组，并确保奇数位放置奇数，偶数位放置偶数。
    • oddIndex 指针用于查找奇数应该放置的位置，evenIndex 指针用于查找偶数应该放置的位置。
    • 如果两个指针指向的位置不符合要求，则交换这两个位置的元素。
  2. printArray(int[] arr):
    • 打印数组的内容，便于调试和查看输出结果。
  3. main:
    • 初始化了一个数组，并调用 rearrangeArray 方法进行重新排列，最后打印出排列后的数组。

示例输入输出

输入：

1
2
javascriptCopy codeOriginal Array:
1 2 3 4 5 6 7 8

输出：

1
2
javascriptCopy codeRearranged Array:
1 2 3 4 5 6 7 8

时间复杂度

  • 时间复杂度：O(n)O(n)O(n)，我们只遍历数组一次，对每个元素做交换。
  • 空间复杂度：O(1)O(1)O(1)，仅用了常量空间。

如果有其他问题或需要进一步优化，欢迎随时提问！

问：统计一个字符串的字符出现字数并打印?除了这个还有别的办法吗？

要统计一个字符串中每个字符出现的次数，并打印出来，最常用的方法是使用哈希表（例如 HashMap）。这种方法可以以 O(n)O(n) 的时间复杂度完成任务，其中 nn 是字符串的长度。

方法 1：使用 HashMap 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.HashMap;
import java.util.Map;

public class CharacterFrequency {
    
    public static void countCharacterFrequency(String str) {
        // 使用 HashMap 统计每个字符的频率
        Map<Character, Integer> frequencyMap = new HashMap<>();
        
        // 遍历字符串，统计每个字符出现的次数
        for (char c : str.toCharArray()) {
            frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);
        }
        
        // 打印结果
        for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    public static void main(String[] args) {
        String str = "aabccba";
        countCharacterFrequency(str);
    }
}

输出示例：

1
2
3
a: 3
b: 2
c: 2

时间复杂度：

  • 时间复杂度：O(n)O(n)，其中 nn 是字符串的长度。我们只需要遍历一次字符串。
  • 空间复杂度：O(k)O(k)，其中 kk 是字符串中不同字符的数量。如果是英文字母，最多为 26 或 256（ASCII 字符集）。

另外的实现方式：

方法 2：使用数组计数（适用于固定字符集）

如果我们知道字符串只包含特定字符集（如小写字母或 ASCII 字符），可以使用数组代替 HashMap 来减少空间复杂度。比如，如果字符串只包含小写字母，则可以使用大小为 26 的数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class CharacterFrequency {
    
    public static void countCharacterFrequency(String str) {
        // 假设字符串只包含小写字母
        int[] frequency = new int[26];
        
        // 遍历字符串，统计每个字符出现的次数
        for (char c : str.toCharArray()) {
            frequency[c - 'a']++;
        }
        
        // 打印结果
        for (int i = 0; i < frequency.length; i++) {
            if (frequency[i] > 0) {
                System.out.println((char) (i + 'a') + ": " + frequency[i]);
            }
        }
    }

    public static void main(String[] args) {
        String str = "aabccba";
        countCharacterFrequency(str);
    }
}

输出示例：

1
2
3
a: 3
b: 2
c: 2

时间复杂度：

  • 时间复杂度：O(n)O(n)，遍历字符串一次。
  • 空间复杂度：O(1)O(1)，这里我们使用一个固定大小的数组来统计字符频率（大小为 26，因为只考虑小写字母）。

方法 3：排序 + 扫描

如果字符串不大且不要求频繁操作，也可以先将字符串排序，然后扫描字符串并统计相同字符的个数。这种方法的时间复杂度较高，因为排序的时间复杂度是 O(nlog⁡n)O(n \log n)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Arrays;

public class CharacterFrequency {

    public static void countCharacterFrequency(String str) {
        // 将字符串转换为字符数组并排序
        char[] charArray = str.toCharArray();
        Arrays.sort(charArray);
        
        // 扫描字符数组，统计频率
        int count = 1;
        for (int i = 1; i < charArray.length; i++) {
            if (charArray[i] == charArray[i - 1]) {
                count++;
            } else {
                System.out.println(charArray[i - 1] + ": " + count);
                count = 1;
            }
        }
        // 打印最后一个字符的频率
        System.out.println(charArray[charArray.length - 1] + ": " + count);
    }

    public static void main(String[] args) {
        String str = "aabccba";
        countCharacterFrequency(str);
    }
}

输出示例：

1
2
3
a: 3
b: 2
c: 2

时间复杂度：

  • 时间复杂度：O(nlog⁡n)O(n \log n)，排序的时间复杂度为 O(nlog⁡n)O(n \log n)，然后扫描字符串的时间复杂度是 O(n)O(n)。
  • 空间复杂度：O(n)O(n)，需要存储字符数组。

总结：

  1. HashMap 方法是最常见且高效的，适用于通用情况，可以处理任意字符集。
  2. 数组计数 方法适用于已知字符集（例如只包含小写字母），它是最节省空间的方法。
  3. 排序 + 扫描 方法适用于简单场景，但它的时间复杂度较高。

选择哪种方法取决于字符串的大小、字符集的限制以及是否需要频繁更新。

问：全排列？

全排列问题通常是指给定一个数组或字符串，要求输出该数组或字符串的所有可能的排列方式。全排列是经典的回溯问题。

  1. 全排列的基本思路：
  • 回溯算法：通过交换数组中的元素，生成不同的排列。每次固定一个元素后递归地生成子排列，直到生成所有可能的排列。
  • 去重：如果输入的数组或字符串中有重复元素，需要避免重复排列的生成。
  1. 问题分析：
  • 假设我们有一个数组或字符串 arr，其长度为 n，那么全排列的总数是 n!（n的阶乘）。
  • 通过回溯法可以遍历所有可能的排列，递归地构建每个排列。
  1. 代码实现（Java）：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.util.ArrayList;
import java.util.List;

public class Permutation {

    // 全排列算法
    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> current = new ArrayList<>();
        boolean[] used = new boolean[nums.length]; // 标记哪些元素已经使用
        
        // 回溯算法
        backtrack(nums, used, current, result);
        return result;
    }

    // 回溯函数
    private static void backtrack(int[] nums, boolean[] used, List<Integer> current, List<List<Integer>> result) {
        if (current.size() == nums.length) {  // 如果当前排列已经包含所有元素
            result.add(new ArrayList<>(current)); // 添加到结果中
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue; // 如果元素已被使用过，跳过
            
            // 标记该元素为已使用
            used[i] = true;
            current.add(nums[i]); // 选择该元素

            // 递归构建下一个元素
            backtrack(nums, used, current, result);

            // 回溯，撤销选择
            current.remove(current.size() - 1);
            used[i] = false;
        }
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        List<List<Integer>> result = permute(nums);
        
        // 打印结果
        for (List<Integer> perm : result) {
            System.out.println(perm);
        }
    }
}

输出示例：

1
2
3
4
5
6
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

解释：

  • backtrack 函数：递归地生成所有的排列。每次从未使用过的元素中选择一个，并递归地生成剩下的排列，直到构建出完整的排列。
  • used 数组：用于标记某个元素是否已经出现在当前的排列中，避免重复使用同一个元素。
  • current 列表：用于存储当前的排列。
  • result 列表：用于存储所有的排列。
  1. 时间复杂度：
  • 时间复杂度：O(n!)O(n!)，因为我们需要生成所有可能的排列，其中 n! 是排列的总数。对于每个排列，我们可能会进行 O(n)O(n) 的操作（复制排列）。
  • 空间复杂度：O(n)O(n)，用于存储当前排列的空间，递归调用栈的空间。
  1. 去重的情况（对于重复元素的全排列）：

如果输入的数组中包含重复的元素，需要去重，避免重复的排列被加入结果。可以在回溯时通过排序数组，并在递归中加上去重条件来避免重复排列。

代码改进：加入去重逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Permutation {

    // 全排列算法（考虑重复元素去重）
    public static List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> current = new ArrayList<>();
        boolean[] used = new boolean[nums.length]; // 标记哪些元素已经使用
        
        // 排序是为了方便去重
        Arrays.sort(nums);
        
        // 回溯算法
        backtrack(nums, used, current, result);
        return result;
    }

    // 回溯函数（考虑重复元素去重）
    private static void backtrack(int[] nums, boolean[] used, List<Integer> current, List<List<Integer>> result) {
        if (current.size() == nums.length) {  // 如果当前排列已经包含所有元素
            result.add(new ArrayList<>(current)); // 添加到结果中
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue; // 如果元素已被使用过，跳过
            // 如果当前元素和前一个元素相同，并且前一个元素未被使用，则跳过（避免重复排列）
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;

            // 标记该元素为已使用
            used[i] = true;
            current.add(nums[i]); // 选择该元素

            // 递归构建下一个元素
            backtrack(nums, used, current, result);

            // 回溯，撤销选择
            current.remove(current.size() - 1);
            used[i] = false;
        }
    }

    public static void main(String[] args) {
        int[] nums = {1, 1, 2};
        List<List<Integer>> result = permuteUnique(nums);
        
        // 打印结果
        for (List<Integer> perm : result) {
            System.out.println(perm);
        }
    }
}

输出示例（去重）：

1
2
3
[1, 1, 2]
[1, 2, 1]
[2, 1, 1]

时间复杂度：

  • 时间复杂度：仍为 O(n!)O(n!)，但是我们通过去重来减少了重复排列的生成，避免了不必要的递归调用。
  • 空间复杂度：O(n)O(n)，存储当前排列和递归调用栈。

总结：

  • 生成全排列的基本思路是利用回溯算法，在每一步选择一个未使用的元素，递归地生成所有可能的排列。
  • 对于有重复元素的数组，需要进行去重处理，可以通过排序和跳过相同的元素来避免重复的排列。

问：假如你正在做淘宝的后台，如何快速查询出1000-2000价格的商品？

要快速查询出价格在 1000 到 2000 区间的商品，在设计上需要考虑性能、可扩展性以及高效的查询方式。以下是几个设计思路和解决方案：

  1. 使用索引（数据库层面）

  • 数据库设计：首先要保证数据库中商品表的价格字段（比如 price）有索引。这样，当我们进行基于价格范围的查询时，数据库能够快速定位到匹配的记录。

  • SQL 查询：

    1
    SELECT * FROM products WHERE price BETWEEN 1000 AND 2000;

    这个查询会利用 price 字段的索引（如果有）来快速检索符合条件的商品。

  • 索引优化：为了提高查询性能，确保商品表上的 price 字段有合适的索引。如果有多个条件查询（例如，按价格和类目查询），可以考虑复合索引。

  • 注意：索引可以大大加快查询速度，但在高并发或大量数据情况下，单纯依赖索引还可能会遇到性能瓶颈。这时可以考虑缓存或者分库分表等技术。

  1. 使用分区（Partitioning）

  • 分区策略

    ：当数据量非常大时，可以考虑对商品表进行分区，将商品按价格范围划分成多个子表（例如：每 1000 元一个分区），然后查询时直接针对对应的分区查询。

    • 分区表示例：
      • products_price_0_1000
      • products_price_1000_2000
      • products_price_2000_3000
      • …

  • 好处：可以减小查询的范围，从而提高查询性能。

  1. 使用缓存（Cache）
  • Redis / Memcached 缓存：对于查询频繁的价格范围，可以将结果缓存到内存中，例如使用 Redis 来存储价格区间查询的结果。通过预热缓存，可以避免每次查询都从数据库中获取数据。
    • 示例：可以将查询的价格区间结果（如 1000-2000 范围内的商品列表）存储在 Redis 中，查询时先从 Redis 获取，如果没有再去数据库查询并更新缓存。
  • 缓存更新策略：对于商品价格的更新或新增，应该确保缓存与数据库一致。可以使用如 缓存失效策略 或 定期更新缓存 的方法。
  1. 使用全文检索或搜索引擎（ElasticSearch）

  • ElasticSearch：如果查询的维度不仅仅是价格，还包括类目、品牌、评分等多种条件，传统的关系型数据库可能性能不足，特别是对于大规模数据的检索。可以使用搜索引擎（如 ElasticSearch）来高效查询商品。

    • ElasticSearch 的优点

      ：

      • 分布式：可以横向扩展，处理超大规模数据。
      • 高效查询：支持快速的区间查询，并且可以利用 倒排索引 提供非常高效的检索能力。
      • 聚合查询：支持复杂的聚合和筛选操作。

    • ElasticSearch 查询示例

      （查询价格区间的商品）：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      {
        "query": {
          "range": {
            "price": {
              "gte": 1000,
              "lte": 2000
            }
          }
        }
      }

  • 优点：ElasticSearch 是针对高效搜索和过滤场景设计的，适合做复杂的查询和范围查找。

  1. 物理设计优化
  • 合理的表设计：确保商品表具有合理的字段设计，例如每个商品的价格字段 price 应该使用合适的数据类型（如 DECIMAL 或 FLOAT）。
  • 数据类型选择：如果价格字段的数据类型不合适（例如 VARCHAR），可能会导致查询时的性能问题，尽量使用数值型的数据类型来存储价格。
  1. 分页查询与优化

  • 如果商品数量较多，需要返回所有符合条件的商品，可以进行分页查询，以减少每次查询的负载。

    1
    SELECT * FROM products WHERE price BETWEEN 1000 AND 2000 LIMIT 100 OFFSET 200;

  • 在高并发场景下，使用 游标分页 或 基于时间戳的分页 会比 LIMIT + OFFSET 更高效，因为后者随着偏移量的增加会有较大的性能开销。

总结：

查询方式：

  1. 使用数据库索引：保证商品表的价格字段有索引，利用 BETWEEN 语句快速查询。
  2. 分区：将商品表按价格范围分区，在大数据量下减少查询的范围。
  3. 缓存：使用 Redis 等缓存机制缓存价格区间查询结果，减少对数据库的压力。
  4. 搜索引擎：使用 ElasticSearch 等搜索引擎进行高效的范围查询，特别是当查询条件复杂时。

其他考虑：

  • 查询频率与更新频率：高频查询可以通过缓存优化，低频查询则可以直接依赖数据库查询。
  • 数据一致性：对于缓存方案，要确保缓存和数据库的一致性，避免缓存不更新导致数据不一致。

使用这些方法可以在保证查询效率的同时，确保系统能够快速响应并处理大量商品数据。

问：有一个场景，一个背包里，多个线程往里面移走东西如何保证线程安全？加锁加在什么地方，让你来写代码你怎么写？

在这个场景中，我们需要保证多个线程同时操作背包时，能避免数据不一致或竞争条件的发生。假设这个背包可以存放物品，每个物品有一定的重量、价值等属性。为了实现线程安全的操作，我们可以使用加锁机制，确保在同一时间只有一个线程能访问背包。

思路

  1. 使用锁保证互斥性：使用锁（例如 synchronized 或 ReentrantLock）来确保多个线程在访问背包时，只有一个线程能执行修改背包内容的操作。
  2. 锁的粒度：锁的粒度越大，性能开销也越大，因此应该尽量减小锁的作用范围。理想情况下，我们只需要在修改背包状态时加锁，而在读取背包状态时可以避免加锁（如果可以保证读操作的线程安全）。

问题分析：

  • 背包的内容应该是线程安全的，多个线程可能同时尝试修改它，因此我们需要加锁来保护对背包的修改操作。
  • 在本例中，加锁应该放在修改背包内容（如放入物品、取走物品等）的关键代码段。

Java 代码实现

首先定义一个 Backpack 类，包含一些基本的操作，例如放入物品和移走物品。

  1. 使用 synchronized 锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class Item {
    String name;
    int weight;
    int value;

    public Item(String name, int weight, int value) {
        this.name = name;
        this.weight = weight;
        this.value = value;
    }
}

class Backpack {
    private List<Item> items = new ArrayList<>();
    private int capacity;

    public Backpack(int capacity) {
        this.capacity = capacity;
    }

    // 添加物品到背包
    public synchronized boolean addItem(Item item) {
        if (getTotalWeight() + item.weight <= capacity) {
            items.add(item);
            return true;
        }
        return false;
    }

    // 从背包中移走物品
    public synchronized boolean removeItem(Item item) {
        if (items.contains(item)) {
            items.remove(item);
            return true;
        }
        return false;
    }

    // 获取背包中所有物品的总重量
    private int getTotalWeight() {
        int totalWeight = 0;
        for (Item item : items) {
            totalWeight += item.weight;
        }
        return totalWeight;
    }

    // 获取背包中物品的列表
    public List<Item> getItems() {
        return items;
    }
}

代码解释：

  1. 加锁位置：addItem 和 removeItem 方法用 synchronized 关键字加锁，确保每次只有一个线程能执行对背包的修改操作（如添加或移走物品）。

  2. 锁的粒度：synchronized 会在方法执行时加锁，保证一个线程在执行过程中不会被其他线程干扰，直到执行完方法，释放锁。

  3. 读取操作：在本例中，获取背包物品的列表 (getItems) 不加锁，因为读取操作不会修改背包状态。如果对读取操作有其他需求（比如确保在读取时数据一致），可以考虑在读取时加锁，或者使用 ReadWriteLock。

  4. 使用 ReentrantLock

ReentrantLock 提供了更细粒度的控制，并且支持尝试锁（tryLock）等功能。我们可以使用 ReentrantLock 来替代 synchronized，来控制背包的修改操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BackpackWithLock {
    private List<Item> items = new ArrayList<>();
    private int capacity;
    private Lock lock = new ReentrantLock();

    public BackpackWithLock(int capacity) {
        this.capacity = capacity;
    }

    // 添加物品到背包
    public boolean addItem(Item item) {
        lock.lock();  // 手动加锁
        try {
            if (getTotalWeight() + item.weight <= capacity) {
                items.add(item);
                return true;
            }
            return false;
        } finally {
            lock.unlock();  // 确保释放锁
        }
    }

    // 从背包中移走物品
    public boolean removeItem(Item item) {
        lock.lock();
        try {
            if (items.contains(item)) {
                items.remove(item);
                return true;
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

    // 获取背包中所有物品的总重量
    private int getTotalWeight() {
        int totalWeight = 0;
        for (Item item : items) {
            totalWeight += item.weight;
        }
        return totalWeight;
    }

    // 获取背包中物品的列表
    public List<Item> getItems() {
        return items;
    }
}

代码解释：

  1. **使用 ReentrantLock**：与 synchronized 不同，ReentrantLock 允许更灵活的控制，支持手动锁定和解锁。

  2. 锁的控制：通过调用 lock.lock() 来加锁，执行完操作后调用 lock.unlock() 释放锁。确保在发生异常时也能释放锁（通过 finally 块确保）。

  3. 优点：相较于 synchronized，ReentrantLock 可以支持公平锁（ReentrantLock(true)）、尝试锁定（tryLock）等更多的功能。

  4. 线程池管理（可选）

如果你希望让多个线程并发地操作背包并且提高性能，可以考虑使用线程池来管理线程。比如在背包的操作中使用线程池来模拟多线程并发操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BackpackTest {
    public static void main(String[] args) {
        Backpack backpack = new Backpack(100);
        ExecutorService executor = Executors.newFixedThreadPool(10);  // 创建一个线程池

        // 模拟多线程同时操作背包
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executor.submit(() -> {
                Item item = new Item("item" + index, 10, 100);
                if (backpack.addItem(item)) {
                    System.out.println("Successfully added " + item.name);
                } else {
                    System.out.println("Failed to add " + item.name);
                }
            });
        }

        executor.shutdown();
    }
}

关键点：

  • 线程池：通过使用 ExecutorService 可以模拟多个线程并发执行操作，并且方便地管理线程生命周期。
  • 安全性：保证背包的操作是线程安全的，通过锁机制（synchronized 或 ReentrantLock）保证多个线程不会同时修改背包数据。

总结：

  • 加锁的位置：加锁应该放在对背包内容有修改的关键代码段（如 addItem 和 removeItem）。
  • 锁的粒度：尽量在小范围内加锁，避免锁住不必要的代码，减少性能开销。
  • 使用线程池：多线程操作时使用线程池管理，可以有效利用系统资源并避免线程的过度创建销毁。

时间复杂度：

  • **addItem 和 removeItem**：每次操作需要遍历背包中的物品（若是顺序查找或移除），时间复杂度为 O(n)，其中 n 是背包中物品的数量。
  • 获取背包物品列表（getItems）：O(n)。

空间复杂度：

  • 空间复杂度为 O(n)，其中 n 是背包中物品的数量，存储物品列表的空间需求。

问：判断数组里是否有和为指定值的两个数？

要判断一个数组中是否存在两个数，它们的和为指定值，可以通过以下几种方法来实现。

方法 1: 暴力法

暴力法的基本思路是遍历数组中的每一对元素，检查它们的和是否等于指定值。这种方法时间复杂度为 O(n2)O(n^2)，空间复杂度为 O(1)O(1)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TwoSum {
    public static boolean hasPairWithSum(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] + arr[j] == target) {
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 6, 8, 9};
        int target = 10;
        System.out.println(hasPairWithSum(arr, target));  // Output: true
    }
}

时间复杂度：

  • 时间复杂度: O(n2)O(n^2)，因为需要检查每一对元素。
  • 空间复杂度: O(1)O(1)，没有使用额外的空间。

方法 2: 哈希表法

哈希表法的基本思路是使用一个哈希集合来存储数组中的元素。对于每一个元素，判断目标值减去该元素的差值是否已经存在于哈希表中。如果存在，说明找到了这两个数，否则将当前元素加入哈希表。这种方法时间复杂度为 O(n)O(n)，空间复杂度为 O(n)O(n)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.HashSet;

public class TwoSum {
    public static boolean hasPairWithSum(int[] arr, int target) {
        HashSet<Integer> seen = new HashSet<>();
        for (int num : arr) {
            if (seen.contains(target - num)) {
                return true;
            }
            seen.add(num);
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 6, 8, 9};
        int target = 10;
        System.out.println(hasPairWithSum(arr, target));  // Output: true
    }
}

时间复杂度：

  • 时间复杂度: O(n)O(n)，遍历数组一次，哈希表的插入和查找平均时间复杂度为 O(1)O(1)。
  • 空间复杂度: O(n)O(n)，需要存储一个哈希集合。

方法 3: 排序 + 双指针法

如果数组是无序的，我们可以先对数组进行排序，然后使用双指针的方法：一个指针从数组的开头开始，另一个指针从数组的末尾开始。根据当前两个指针指向的元素之和与目标值的大小关系，调整指针的位置。该方法的时间复杂度为 O(nlog⁡n)O(n \log n)，因为需要对数组进行排序，空间复杂度为 O(1)O(1)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Arrays;

public class TwoSum {
    public static boolean hasPairWithSum(int[] arr, int target) {
        Arrays.sort(arr);  // 排序
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            int sum = arr[left] + arr[right];
            if (sum == target) {
                return true;
            } else if (sum < target) {
                left++;  // 和小于目标，左指针右移
            } else {
                right--;  // 和大于目标，右指针左移
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 6, 8, 9};
        int target = 10;
        System.out.println(hasPairWithSum(arr, target));  // Output: true
    }
}

时间复杂度：

  • 时间复杂度: O(nlog⁡n)O(n \log n)，排序的时间复杂度是 O(nlog⁡n)O(n \log n)，双指针扫描数组的时间复杂度是 O(n)O(n)。
  • 空间复杂度: O(1)O(1)，排序时使用的空间为常数空间（原地排序）。

总结：

  1. 暴力法：时间复杂度 O(n2)O(n^2)，空间复杂度 O(1)O(1)，实现简单，但效率较低。
  2. 哈希表法：时间复杂度 O(n)O(n)，空间复杂度 O(n)O(n)，通过哈希表快速查找，提高效率。
  3. 排序 + 双指针法：时间复杂度 O(nlog⁡n)O(n \log n)，空间复杂度 O(1)O(1)，适用于排序后的数组，节省空间。

对于该问题，通常推荐使用 哈希表法，因为它提供了最好的时间效率。

问：对笔试题进行提问？有没找到更好的解法吗？

(题目大概是一个数组里除了一个数字出现一次，其它数字都出现了两次，给一个最优解法？我说可以用map，key为数字，value为该数字出现次数？面试官给了一个异或的方法，提示两次异或是本身）

这个问题可以通过 异或 操作来高效解决，时间复杂度为 O(n)O(n)，空间复杂度为 O(1)O(1)。具体思路如下：

思路：

  • 异或操作：有一个重要性质：a ^ a = 0 和 a ^ 0 = a。所以，如果我们对所有数组中的元素进行异或操作，两个相同的数字会相互抵消，最后剩下的就是那个只出现一次的数字。
  • 时间复杂度：由于我们只需要遍历一次数组，时间复杂度为 O(n)O(n)。
  • 空间复杂度：不需要额外的空间，空间复杂度为 O(1)O(1)。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SingleNumber {
    public static int findSingleNumber(int[] arr) {
        int result = 0;
        for (int num : arr) {
            result ^= num;  // 对数组中的所有元素进行异或操作
        }
        return result;  // 最后返回的就是那个只出现一次的数字
    }

    public static void main(String[] args) {
        int[] arr = {4, 3, 2, 4, 1, 3, 2};  // 1 是唯一只出现一次的数字
        System.out.println(findSingleNumber(arr));  // Output: 1
    }
}

时间复杂度：

  • 时间复杂度：O(n)O(n)，我们只遍历了数组一次，其中 nn 是数组的长度。

空间复杂度：

  • 空间复杂度：O(1)O(1)，只用了一个常量大小的 result 变量。

为什么这个方法有效？

  • 异或操作会抵消重复出现的数字，因此最后剩下的就是那个只出现一次的数字。
  • 即使数组长度非常大，遍历一次数组并进行异或操作是非常高效的。

三.算法题

leetcode面试经典150题

3.1 数组/字符串 Arrays/Strings

88.合并两个有序数组 <easy> 双指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/*    给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

    请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

    注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

    示例 1：

    输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
    输出：[1,2,2,3,5,6]
    解释：需要合并 [1,2,3] 和 [2,5,6] 。
    合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
    示例 2：

    输入：nums1 = [1], m = 1, nums2 = [], n = 0
    输出：[1]
    解释：需要合并 [1] 和 [] 。
    合并结果是 [1] 。
    示例 3：

    输入：nums1 = [0], m = 0, nums2 = [1], n = 1
    输出：[1]
    解释：需要合并的数组是 [] 和 [1] 。
    合并结果是 [1] 。
    注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。


    提示：

    nums1.length == m + n
    nums2.length == n
0 <= m, n <= 200
            1 <= m + n <= 200
            -109 <= nums1[i], nums2[j] <= 109


    进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？*/
public class MergeTwoSortedArrays88 {

    public static void merge(int[] nums1, int m, int[] nums2, int n) {
        //// 1.先合并后排序
        //for (int i = 0; i != n; ++i) {
        //    nums1[m + i] = nums2[i];
        //}
        //// 排序序列长度为 m+n，套用快速排序的时间复杂度即可，平均情况为 O((m+n)log(m+n))
        //Arrays.sort(nums1);

        //2.逆向双指针，因为数组是有序的，用两个指针分别指向两个数组的首个元素，对比大小
        // 因为数组1后面是空的，所以倒叙遍历可以直接覆盖后面的元素
        int i = m - 1;
        int j = n - 1;
        int k = m + n - 1;

        // 循环直到两个指针都走完
        while (i >= 0 && j >= 0) {
            // 对比两个数组，较大的值放入队尾
            if (nums1[i] > nums2[j]) {
                nums1[k--] = nums1[i--];
            } else {
                nums1[k--] = nums2[j--];
            }
        }

        // 若数组1为空则遍历数组2放入数组1
        while (j >= 0) {
            nums1[k--] = nums2[j--];
        }
        // 时间复杂大为O(m + n)，因为只需要遍历一遍两个数组，进行一次比较和移动操作
    }


    public static void main(String[] args) {
        int[] nums1_1 = {1, 2, 3, 0, 0, 0};
        int[] nums2_1 = {2, 5, 6};
        int m1 = 3;
        int n1 = 3;

        merge(nums1_1, m1, nums2_1, n1);
        System.out.print("Test Case 1: ");
        System.out.println(Arrays.toString(nums1_1));

        int[] nums1_2 = {1};
        int[] nums2_2 = {};
        int m2 = 1;
        int n2 = 0;

        merge(nums1_2, m2, nums2_2, n2);
        System.out.print("Test Case 2: ");
        System.out.println(Arrays.toString(nums1_2));

        int[] nums1_3 = {0};
        int[] nums2_3 = {1};
        int m3 = 0;
        int n3 = 1;

        merge(nums1_3, m3, nums2_3, n3);
        System.out.print("Test Case 3: ");
        System.out.println(Arrays.toString(nums1_3));
    }
}

27. 移除元素 <easy> 双指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

/*给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

        不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

        元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。



        说明:

        为什么返回数值是整数，但输出的答案是数组呢?

        请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

        你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
        int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
        for (int i = 0; i < len; i++) {
        print(nums[i]);
        }


        示例 1：

        输入：nums = [3,2,2,3], val = 3
        输出：2, nums = [2,2]
        解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
        示例 2：

        输入：nums = [0,1,2,2,3,0,4,2], val = 2
        输出：5, nums = [0,1,3,0,4]
        解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。


        提示：

        0 <= nums.length <= 100
        0 <= nums[i] <= 50
        0 <= val <= 100*/

public class RemoveElement27 {

    public static int removeElement(int[] nums, int val) {
        // 因为不需要考虑数组中超出新长度后面的元素，并且一次遍历完成操作，所以直接覆盖原数组元素即可
        int i = 0;
        for (int j = 0; j < nums.length; j++) {
            if (nums[j] != val) {
                nums[i] = nums[j];
                i++;
            }
        }
        return i;
        // 时间复杂大为O(n)，因为只需要遍历一遍数组
    }

    public static void main(String[] args) {
        int[] nums1 = {3, 2, 2, 3};
        int val1 = 3;
        int len1 = removeElement(nums1, val1);
        System.out.println("Test Case 1:");
        System.out.println("Length: " + len1 + ", nums = ");
        printArray(nums1, len1);

        int[] nums2 = {0, 1, 2, 2, 3, 0, 4, 2};
        int val2 = 2;
        int len2 = removeElement(nums2, val2);
        System.out.println("Test Case 2:");
        System.out.println("Length: " + len2 + ", nums = ");
        printArray(nums2, len2);
    }

    public static void printArray(int[] arr, int len) {
        System.out.print("[");
        for (int i = 0; i < len; i++) {
            if (i < len - 1) {
                System.out.print(arr[i] + ", ");
            } else {
                System.out.print(arr[i]);
            }
        }
        System.out.println("]");
    }
}

26. 删除有序数组中的重复项 <easy> 双指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/*给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

        考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

        更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
        返回 k 。
        判题标准:

        系统会用下面的代码来测试你的题解:

        int[] nums = [...]; // 输入数组
        int[] expectedNums = [...]; // 长度正确的期望答案

        int k = removeDuplicates(nums); // 调用

        assert k == expectedNums.length;
        for (int i = 0; i < k; i++) {
        assert nums[i] == expectedNums[i];
        }
        如果所有断言都通过，那么您的题解将被 通过。

        示例 1：

        输入：nums = [1,1,2]
        输出：2, nums = [1,2,_]
        解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
        示例 2：

        输入：nums = [0,0,1,1,1,2,2,3,3,4]
        输出：5, nums = [0,1,2,3,4]
        解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。


        提示：

        1 <= nums.length <= 3 * 104
        -104 <= nums[i] <= 104
        nums 已按 非严格递增 排列*/
public class RemoveDuplicatesFromSortedArray26 {

    public static int removeDuplicates(int[] nums) {
        // 有序数组的去重和合并，都可以考虑用双指针来解决
        if (nums.length == 0) {
            return 0;
        }
        int i = 0;
        // 相邻元素相等时由后一位替代，不相等时不动
        for(int j = 1;j < nums.length;j++) {
            // 相邻元素相等时i指针不动，直到j指针标到不相等元素时再替换相邻的下一个元素
            if (nums[i] != nums[j]) {
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
        // 时间复杂度是 O(n)
    }


    public static void printArray(int[] arr, int len) {
        System.out.print("[");
        for (int i = 0; i < len; i++) {
            if (i < len - 1) {
                System.out.print(arr[i] + ", ");
            } else {
                System.out.print(arr[i]);
            }
        }
        System.out.println("]");
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 1, 2};
        int k1 = removeDuplicates(nums1);
        System.out.println("Test Case 1:");
        System.out.println("Length: " + k1 + ", nums = ");
        printArray(nums1, k1);

        int[] nums2 = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4};
        int k2 = removeDuplicates(nums2);
        System.out.println("Test Case 2:");
        System.out.println("Length: " + k2 + ", nums = ");
        printArray(nums2, k2);
    }
}

80. 删除有序数组中的重复项 II <medium> 双指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

        不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。



        说明：

        为什么返回数值是整数，但输出的答案是数组呢？

        请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

        你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
        int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
        for (int i = 0; i < len; i++) {
        print(nums[i]);
        }


        示例 1：

        输入：nums = [1,1,1,2,2,3]
        输出：5, nums = [1,1,2,2,3]
        解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。
        示例 2：

        输入：nums = [0,0,1,1,1,1,2,3,3]
        输出：7, nums = [0,0,1,1,2,3,3]
        解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。


        提示：

        1 <= nums.length <= 3 * 104
        -104 <= nums[i] <= 104
        nums 已按升序排列*/
public class RemoveDuplicatesFromSortedArray80 {
    public static int removeDuplicates(int[] nums) {
        if (nums.length <= 2) {
            return nums.length;
        }

        // 双指针
        int slow = 2;
        for (int fast = 2; fast < nums.length; fast++) {
            // 跨两位比较，当值不匹配是双指针同速，匹配则慢指针停留，直到下一个不相等时与后面相隔位置交换
            if (nums[slow - 2] != nums[fast]) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        // 时间复杂度是 O(n)
        return slow;
    }

    public static void printArray(int[] arr, int len) {
        System.out.print("[");
        for (int i = 0; i < len; i++) {
            if (i < len - 1) {
                System.out.print(arr[i] + ", ");
            } else {
                System.out.print(arr[i]);
            }
        }
        System.out.println("]");
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 1, 1, 2, 2, 3};
        int k1 = removeDuplicates(nums1);
        System.out.println("Test Case 1:");
        System.out.println("Length: " + k1 + ", nums = ");
        printArray(nums1, k1);

        int[] nums2 = {0, 0, 1, 1, 1, 1, 2, 3, 3};
        int k2 = removeDuplicates(nums2);
        System.out.println("Test Case 2:");
        System.out.println("Length: " + k2 + ", nums = ");
        printArray(nums2, k2);
    }
}

169. 多数元素 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/*给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

        你可以假设数组是非空的，并且给定的数组总是存在多数元素。



        示例 1：

        输入：nums = [3,2,3]
        输出：3
        示例 2：

        输入：nums = [2,2,1,1,1,2,2]
        输出：2


        提示：
        n == nums.length
        1 <= n <= 5 * 104
        -109 <= nums[i] <= 109


        进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。*/
public class MajorityElement169 {
    public static int majorityElement(int[] nums) {
        int count = 0;
        int candidate = 0;

        for (int num : nums) {
            if (count == 0) {
                candidate = num;
            }
            // 命中则+1，否则-1，直到count减为0则换为新的，最终留下的则是多数元素，否则说明没有超过1/2的元素
            count += (num == candidate) ? 1 : -1;
        }

        return candidate;
    }

    public static void main(String[] args) {
        int[] nums1 = {3, 2, 3};
        int result1 = majorityElement(nums1);
        System.out.println("Test Case 1:");
        System.out.println("Majority Element: " + result1);

        int[] nums2 = {2, 2, 1, 1, 1, 2, 2};
        int result2 = majorityElement(nums2);
        System.out.println("Test Case 2:");
        System.out.println("Majority Element: " + result2);

        int[] nums3 = {1, 2, 3};
        int result3 = majorityElement(nums3);
        System.out.println("Test Case 3:");
        System.out.println("Majority Element: " + result3);
    }
}

189. 轮转数组 <medium> 数组翻转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
/*给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

        示例 1:

        输入: nums = [1,2,3,4,5,6,7], k = 3
        输出: [5,6,7,1,2,3,4]
        解释:
        向右轮转 1 步: [7,1,2,3,4,5,6]
        向右轮转 2 步: [6,7,1,2,3,4,5]
        向右轮转 3 步: [5,6,7,1,2,3,4]
        示例 2:

        输入：nums = [-1,-100,3,99], k = 2
        输出：[3,99,-1,-100]
        解释:
        向右轮转 1 步: [99,-1,-100,3]
        向右轮转 2 步: [3,99,-1,-100]


        提示：

        1 <= nums.length <= 105
        -231 <= nums[i] <= 231 - 1
        0 <= k <= 105


        进阶：

        尽可能想出更多的解决方案，至少有 三种 不同的方法可以解决这个问题。
        你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？*/
public class RotateArray189 {

    public static void rotate(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        // 第一次倒转，将整个数组倒转 7，6，5，4，3，2，1
        reverse(nums, 0, n - 1);
        // 第二次倒转，将前k个元素倒转 5，6，7，4，3，2，1
        reverse(nums, 0, k - 1);
        // 第三次倒转，将后面的元素倒转 5，6，7，1，2，3，4
        reverse(nums, k, n - 1);
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 2, 3, 4, 5, 6, 7};
        int k1 = 3;
        rotate(nums1, k1);
        System.out.println("Test Case 1:");
        System.out.println(Arrays.toString(nums1));

        int[] nums2 = {-1, -100, 3, 99};
        int k2 = 2;
        rotate(nums2, k2);
        System.out.println("Test Case 2:");
        System.out.println(Arrays.toString(nums2));
    }

    // 使用额外数组 O(n)
    public static void rotateExtraArray(int[] nums, int k) {
        int n = nums.length;
        int[] result = new int[n];
        for (int i = 0; i < n; i++) {
            // 通过取余数来实现循环右移
            result[(i + k) % n] = nums[i];
        }
        System.arraycopy(result, 0, nums, 0, n);
    }

    // 暴力旋转 O(n * k)
    public static void rotateBruteForce(int[] nums, int k) {
        // 每次循环数组右移1位，直到右移K位
        for (int i = 0;i < k;i++) {
            int end = nums[nums.length - 1];
            for (int j = nums.length - 1;j > -1; j--) {
                if (j == 0) {
                    nums[j] = end;
                } else {
                    nums[j] = nums[j - 1];
                }
            }
        }
    }

    // 翻转数组 O(n)
    public static void rotateReverse(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }

    private static void reverse(int[] nums, int start, int end) {
        // 首位调转位置
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
}

121. 买卖股票的最佳时机 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/*给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

        你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

        返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。



        示例 1：

        输入：[7,1,5,3,6,4]
        输出：5
        解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
        注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
        示例 2：

        输入：prices = [7,6,4,3,1]
        输出：0
        解释：在这种情况下, 没有交易完成, 所以最大利润为 0。


        提示：

        1 <= prices.length <= 105
        0 <= prices[i] <= 104*/
public class BestTimeToBuyAndSellStock121 {

    public static int maxProfit(int[] prices) {
        //int buy;
        //int sale;
        //int result = 0;
        //for (int i = 0;i < prices.length;i++) {
        //    buy = prices[i];
        //    for (int j = i+1;j < prices.length;j++) {
        //        sale = prices[j];
        //        result = Math.max((sale - buy), result);
        //    }
        //}
        //result = Math.max(0, result);
        // O(n^2)
        //return result;
        int maxProfit = 0;
        int minPrice = Integer.MAX_VALUE;
        for (int price : prices) {
            // 取当前最小价格
            minPrice = Math.min(minPrice, price);
            // 取当前最大差值
            maxProfit = Math.max(maxProfit, price - minPrice);
        }
        // O(n)
        return maxProfit;
    }

    public static void main(String[] args) {
        int[] prices1 = {7, 1, 5, 3, 6, 4};
        int maxProfit1 = maxProfit(prices1);
        System.out.println("Test Case 1:");
        System.out.println("Max Profit: " + maxProfit1);

        int[] prices2 = {7, 6, 4, 3, 1};
        int maxProfit2 = maxProfit(prices2);
        System.out.println("Test Case 2:");
        System.out.println("Max Profit: " + maxProfit2);

        int[] prices3 = {4, 6, 3, 5, 1, 2};
        int maxProfit3 = maxProfit(prices3);
        System.out.println("Test Case 3:");
        System.out.println("Max Profit: " + maxProfit3);
    }

}

122. 买卖股票的最佳时机 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/*给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

        在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

        返回 你能获得的 最大 利润 。



        示例 1：

        输入：prices = [7,1,5,3,6,4]
        输出：7
        解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
        随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
        总利润为 4 + 3 = 7 。
        示例 2：

        输入：prices = [1,2,3,4,5]
        输出：4
        解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
        总利润为 4 。
        示例 3：

        输入：prices = [7,6,4,3,1]
        输出：0
        解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。


        提示：

        1 <= prices.length <= 3 * 104
        0 <= prices[i] <= 104*/
public class BestTimeToBuyAndSellStock122 {

    public static int maxProfit(int[] prices) {
        //int buy = 0;
        //boolean flag = false;
        //int total = 0;
        //for (int i = 0;i < prices.length;i++) {
        //    // 是否卖出
        //    if (flag && (i+1 == prices.length || prices[i+1] < prices[i])) {
        //        total += prices[i] - buy;
        //        flag = false;
        //    }
        //    // 是否买入
        //    if (!flag && i+1 != prices.length && prices[i+1] > prices[i]) {
        //        buy = prices[i];
        //        // 已持有
        //        flag = true;
        //    }
        //}
        //// O(n)
        //return total;

        int maxProfit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) {
                maxProfit += prices[i] - prices[i - 1];
            }
        }
        return maxProfit;
    }

    public static void main(String[] args) {
        int[] prices1 = {7, 1, 5, 3, 6, 4};
        int maxProfit1 = maxProfit(prices1);
        System.out.println("Test Case 1:");
        System.out.println("Max Profit: " + maxProfit1);

        int[] prices2 = {1, 2, 3, 4, 5};
        int maxProfit2 = maxProfit(prices2);
        System.out.println("Test Case 2:");
        System.out.println("Max Profit: " + maxProfit2);

        int[] prices3 = {4, 6, 3, 5, 1, 2};
        int maxProfit3 = maxProfit(prices3);
        System.out.println("Test Case 3:");
        System.out.println("Max Profit: " + maxProfit3);
    }
}

55. 跳跃游戏 <medium> 贪心

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

        判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。



        示例 1：

        输入：nums = [2,3,1,1,4]
        输出：true
        解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
        示例 2：

        输入：nums = [3,2,1,0,4]
        输出：false
        解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。


        提示：

        1 <= nums.length <= 104
        0 <= nums[i] <= 105*/
public class JumpGame55 {

    public static boolean canJump(int[] nums) {
        // //贪心算法
        //int maxLength = 0;
        //for (int i = 0;i < nums.length - 1;i++) {
        //    // 每次更新当前的最远距离
        //    maxLength = Math.max(nums[i], maxLength - 1);
        //    if (maxLength <= 0) {
        //        return false;
        //    }
        //}
        //return true;
        int maxJump = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i > maxJump) {
                return false;
            }
            maxJump = Math.max(maxJump, i + nums[i]);
            if (maxJump >= nums.length - 1) {
                return true;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] nums1 = {2, 3, 1, 1, 4};
        boolean result1 = canJump(nums1);
        System.out.println("Test Case 1:");
        System.out.println("Can Jump: " + result1);

        int[] nums2 = {3, 2, 1, 0, 4};
        boolean result2 = canJump(nums2);
        System.out.println("Test Case 2:");
        System.out.println("Can Jump: " + result2);
    }

}

45. 跳跃游戏 II <medium> 贪心

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

        每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

        0 <= j <= nums[i]
        i + j < n
返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。



        示例 1:

        输入: nums = [2,3,1,1,4]
        输出: 2
        解释: 跳到最后一个位置的最小跳跃数是 2。
        从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
        示例 2:

        输入: nums = [2,3,0,1,4]
        输出: 2


        提示:

        1 <= nums.length <= 104
        0 <= nums[i] <= 1000
        题目保证可以到达 nums[n-1]*/
public class JumpGame45 {
    public static int jump(int[] nums) {
        // 贪心算法
        int jumps = 0;
        int curEnd = 0;
        int curFarthest = 0;

        for (int i = 0; i < nums.length - 1; i++) {
            // 取当前能到达的最远距离
            curFarthest = Math.max(curFarthest, i + nums[i]);
            // 到达跳跃处，更新跳跃次数
            if (i == curEnd) {
                jumps++;
                curEnd = curFarthest;
            }
        }

        // O(n)
        return jumps;
    }

    public static void main(String[] args) {
        int[] nums1 = {2, 3, 1, 1, 4};
        int minJumps1 = jump(nums1);
        System.out.println("Test Case 1:");
        System.out.println("Minimum Jumps: " + minJumps1);

        int[] nums2 = {2, 3, 0, 1, 4};
        int minJumps2 = jump(nums2);
        System.out.println("Test Case 2:");
        System.out.println("Minimum Jumps: " + minJumps2);
    }
}

274. H 指数 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。

        根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数 是指他（她）至少发表了 h 篇论文，并且 至少 有 h 篇论文被引用次数大于等于 h 。如果 h 有多种可能的值，h 指数 是其中最大的那个。



        示例 1：

        输入：citations = [3,0,6,1,5]
        输出：3
        解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
        由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
        示例 2：

        输入：citations = [1,3,1]
        输出：1


        提示：

        n == citations.length
        1 <= n <= 5000
        0 <= citations[i] <= 1000*/
public class HIndex274 {

    public static int hIndex(int[] citations) {
        int n = citations.length;
        // 存储每个引用次数对应的论文数量，引用数量超过论文数量的统计到队尾
        int[] count = new int[n + 1];

        for (int citation : citations) {
            // count的下标对应引用次数，值则对应论文数量
            if (citation >= n) {
                count[n]++;
            } else {
                count[citation]++;
            }
        }

        // 倒叙遍历，累加论文数量，直到满足论文数量 >= 引用次数
        int total = 0;
        for (int i = n; i >= 0; i--) {
            total += count[i];
            if (total >= i) {
                return i;
            }
        }

        // O(n)
        return 0;
    }

    public static void main(String[] args) {
        int[] citations1 = {3, 0, 6, 1, 5};
        int hIndex1 = hIndex(citations1);
        System.out.println("Test Case 1:");
        System.out.println("H-Index: " + hIndex1);

        int[] citations2 = {1, 3, 1};
        int hIndex2 = hIndex(citations2);
        System.out.println("Test Case 2:");
        System.out.println("H-Index: " + hIndex2);
    }
}

380. O(1) 时间插入、删除和获取随机元素 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/*实现RandomizedSet 类：

        RandomizedSet() 初始化 RandomizedSet 对象
        bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
        bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
        int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。
        你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。



        示例：

        输入
        ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
        [[], [1], [2], [2], [], [1], [2], []]
        输出
        [null, true, false, true, 2, true, false, 2]

        解释
        RandomizedSet randomizedSet = new RandomizedSet();
        randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
        randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
        randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
        randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
        randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
        randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
        randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。


        提示：

        -231 <= val <= 231 - 1
        最多调用 insert、remove 和 getRandom 函数 2 * 105 次
        在调用 getRandom 方法时，数据结构中 至少存在一个 元素。*/
public class InsertDeleteGetrandomO1380 {

    public static void main(String[] args) {
        RandomizedSet randomizedSet = new RandomizedSet();
        System.out.println(randomizedSet.insert(1)); // true
        System.out.println(randomizedSet.remove(2)); // false
        System.out.println(randomizedSet.insert(2)); // true
        System.out.println(randomizedSet.getRandom()); // Random, either 1 or 2
        System.out.println(randomizedSet.remove(1)); // true
        System.out.println(randomizedSet.insert(2)); // false
        System.out.println(randomizedSet.getRandom()); // Always 2
    }
}

public class RandomizedSet {
    private List<Integer> nums;
    private Map<Integer, Integer> indexMap;
    private Random random;

    public RandomizedSet() {
        nums = new ArrayList<>();
        indexMap = new HashMap<>();
        random = new Random();
    }

    public boolean insert(int val) {
        // 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 
        if (indexMap.containsKey(val)) return false;
        nums.add(val);
        // Map的值存放val对应数组的下标
        indexMap.put(val, nums.size() - 1);
        return true;
    }

    public boolean remove(int val) {
        // 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
        if (!indexMap.containsKey(val)) return false;
        // 获取Map中val的值，对应数组中元素的下标
        int index = indexMap.get(val);
        // 获取数组末尾元素
        int lastNum = nums.get(nums.size() - 1);
        // 将末尾元素分别替换val在数组和Map中的位置
        nums.set(index, lastNum);
        indexMap.put(lastNum, index);
        // 分别删除数组和Map的末尾
        nums.remove(nums.size() - 1);
        indexMap.remove(val);
        return true;
    }

    public int getRandom() {
        return nums.get(random.nextInt(nums.size()));
    }
}

238. 除自身以外数组的乘积 <medium> 额外数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/*给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

        题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。

        请 不要使用除法，且在 O(n) 时间复杂度内完成此题。



        示例 1:

        输入: nums = [1,2,3,4]
        输出: [24,12,8,6]
        示例 2:

        输入: nums = [-1,1,0,-3,3]
        输出: [0,0,9,0,0]


        提示：

        2 <= nums.length <= 105
        -30 <= nums[i] <= 30
        保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内


        进阶：你可以在 O(1) 的额外空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组 不被视为 额外空间。）*/
public class ProductOfArrayExceptSelf238 {
    public static int[] productExceptSelf(int[] nums) {
        // 1.两层遍历
        //int[] answer = new int[nums.length];
        //for (int i = 0;i < nums.length;i++) {
        //    answer[i] = 0;
        //    boolean ifSet = false;
        //    for (int j = 0;j < nums.length;j++) {
        //        if (i != j) {
        //            if (!ifSet) {
        //                answer[i] =  nums[j];
        //                ifSet = true;
        //            } else {
        //                answer[i] *=  nums[j];
        //            }
        //        }
        //    }
        //}
        // O(n^2)
        //return answer;
        // 2.使用2个额外数组，分别记录元素左侧和右侧的乘机，最后将两侧乘机相乘
        //int n = nums.length;
        //int[] leftProducts = new int[n];
        //int[] rightProducts = new int[n];
        //int[] answer = new int[n];
        //
        //// 首次遍历，记录每位元素左边元素的乘机
        //leftProducts[0] = 1;
        //for (int i = 1; i < n; i++) {
        //    leftProducts[i] = leftProducts[i - 1] * nums[i - 1];
        //}
        //
        //// 二次遍历，记录每位元素右边元素的乘机
        //rightProducts[n - 1] = 1;
        //for (int i = n - 2; i >= 0; i--) {
        //    rightProducts[i] = rightProducts[i + 1] * nums[i + 1];
        //}
        //
        //// 最后一次，将左右边相乘
        //for (int i = 0; i < n; i++) {
        //    answer[i] = leftProducts[i] * rightProducts[i];
        //}
        //// 时间空间都为 O(n)
        //return answer;
        // 3.将nums和answer分别作为两个数组记录左右乘机，第二次遍历时即算出最终结果
        int n = nums.length;
        int[] answer = new int[n];

        answer[0] = 1;
        for (int i = 1; i < n; i++) {
            answer[i] = answer[i - 1] * nums[i - 1];
        }

        int rightProduct = 1;
        for (int i = n - 1; i >= 0; i--) {
            answer[i] *= rightProduct;
            rightProduct *= nums[i];
        }

        // 时间O(n) 空间O(1)
        return answer;
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 2, 3, 4};
        System.out.println(Arrays.toString(productExceptSelf(nums1))); // [24, 12, 8, 6]

        int[] nums2 = {-1, 1, 0, -3, 3};
        System.out.println(Arrays.toString(productExceptSelf(nums2))); // [0, 0, 9, 0, 0]

        int[] nums3 = {4, 3, 2, 1, 2};
        System.out.println(Arrays.toString(productExceptSelf(nums3))); // [12,16,24,48,24]
    }
}

134. 加油站 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/*在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

        你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

        给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。



        示例 1:

        输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
        输出: 3
        解释:
        从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
        开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
        开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
        开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
        开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
        开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
        因此，3 可为起始索引。
        示例 2:

        输入: gas = [2,3,4], cost = [3,4,3]
        输出: -1
        解释:
        你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
        我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
        开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
        开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
        你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
        因此，无论怎样，你都不可能绕环路行驶一周。


        提示:

        gas.length == n
        cost.length == n
        1 <= n <= 10^5
        0 <= gas[i], cost[i] <= 10^4*/
public class GasStation134 {
    public static int canCompleteCircuit(int[] gas, int[] cost) {
        // 贪心算法
        int totalGas = 0;
        int currentGas = 0;
        int start = 0;

        for (int i = 0; i < gas.length; i++) {
            totalGas += gas[i] - cost[i];
            currentGas += gas[i] - cost[i];

            // 油不足，跳到下个站点开始
            if (currentGas < 0) {
                currentGas = 0;
                start = i + 1;
            }
        }

        // 总油的正负表示是否能完成全程
        // O(n) O(1)
        return totalGas < 0 ? -1 : start;
    }

    public static void main(String[] args) {
        int[] gas1 = {1, 2, 3, 4, 5};
        int[] cost1 = {3, 4, 5, 1, 2};
        int[] gas2 = {2, 3, 4};
        int[] cost2 = {3, 4, 3};

        testGasStation(gas1, cost1); // Example 1
        testGasStation(gas2, cost2); // Example 2
    }

    public static void testGasStation(int[] gas, int[] cost) {
        int result = canCompleteCircuit(gas, cost);
        System.out.println("Gas: " + Arrays.toString(gas) + ", Cost: " + Arrays.toString(cost));
        System.out.println("Output: " + result);
    }
}

135. 分发糖果 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/*n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

        你需要按照以下要求，给这些孩子分发糖果：

        每个孩子至少分配到 1 个糖果。
        相邻两个孩子评分更高的孩子会获得更多的糖果。
        请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。



        示例 1：

        输入：ratings = [1,0,2]
        输出：5
        解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。
        示例 2：

        输入：ratings = [1,2,2]
        输出：4
        解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
        第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。


        提示：

        n == ratings.length
        1 <= n <= 2 * 10^4
        0 <= ratings[i] <= 2 * 10^4*/
public class Candy135 {
    public static int candy(int[] ratings) {
        int n = ratings.length;
        int[] candies = new int[n];
        Arrays.fill(candies, 1); // 每个孩子初始至少一个糖果

        // 从左到右扫描，确保右边评分高的孩子糖果数比左边多
        for (int i = 1; i < n; i++) {
            if (ratings[i] > ratings[i - 1]) {
                candies[i] = candies[i - 1] + 1;
            }
        }

        // 从右到左扫描，确保左边评分高的孩子糖果数比右边多
        for (int i = n - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                candies[i] = Math.max(candies[i], candies[i + 1] + 1);
            }
        }

        int sum = 0;
        for (int candy : candies) {
            sum += candy;
        }

        // O(n) O(n)
        return sum;
    }

    public static void main(String[] args) {
        int[] ratings1 = {1, 0, 2};
        System.out.println("需要准备的最少糖果数目：" + candy(ratings1)); // 输出：5

        int[] ratings2 = {1, 2, 2};
        System.out.println("需要准备的最少糖果数目：" + candy(ratings2)); // 输出：4
    }
}

42. 接雨水 <hard> 双指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/*给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。


        示例 1：

        输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
        输出：6
        解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
        示例 2：

        输入：height = [4,2,0,3,2,5]
        输出：9


        提示：

        n == height.length
        1 <= n <= 2 * 104
        0 <= height[i] <= 105*/
public class TrappingRainWater42 {

    public static int trap(int[] height) {
        // 使用栈或双指针的方式来解决
        if (height == null || height.length == 0) {
            return 0;
        }

        // 两个指针 left 和 right 分别位于数组的最左端和最右端
        int left = 0, right = height.length - 1;
        // 定义了两个变量 leftMax 和 rightMax 来分别记录左右两侧柱子的最大高度
        int leftMax = 0, rightMax = 0;
        int totalWater = 0;

        // 利用 while 循环不断更新 left 和 right 指针位置的高度，并计算蓄水量。随着指针移动，最终可以得到能接的雨水总量。
        while (left < right) {
            leftMax = Math.max(leftMax, height[left]);
            rightMax = Math.max(rightMax, height[right]);

            // 哪边低移动哪边指针
            if (leftMax < rightMax) {
                // 蓄水量就是左边的最高减去当前高度
                totalWater += leftMax - height[left];
                left++;
            } else {
                // 蓄水量就是右边的最高减去当前高度
                totalWater += rightMax - height[right];
                right--;
            }
        }

        //该方法的时间复杂度为 O(N)，空间复杂度为 O(1)，只使用了常量级别的额外空间。
        return totalWater;
    }

    public static void main(String[] args) {
        int[] height1 = {0,1,0,2,1,0,1,3,2,1,2,1};
        int[] height2 = {4,2,0,3,2,5};

        System.out.println("Test Case 1: " + trap(height1)); // Output: 6
        System.out.println("Test Case 2: " + trap(height2)); // Output: 9
    }
}

13. 罗马数字转整数 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/*罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

        字符          数值
        I             1
        V             5
        X             10
        L             50
        C             100
        D             500
        M             1000
        例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

        通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

        I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
        X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
        C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
        给定一个罗马数字，将其转换成整数。

        示例 1:

        输入: s = "III"
        输出: 3
        示例 2:

        输入: s = "IV"
        输出: 4
        示例 3:

        输入: s = "IX"
        输出: 9
        示例 4:

        输入: s = "LVIII"
        输出: 58
        解释: L = 50, V= 5, III = 3.
        示例 5:

        输入: s = "MCMXCIV"
        输出: 1994
        解释: M = 1000, CM = 900, XC = 90, IV = 4.


        提示：

        1 <= s.length <= 15
        s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
        题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
        题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
        IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
        关于罗马数字的详尽书写规则，可以参考 罗马数字 - Mathematics 。*/
public class RomanToInteger13 {
    public static int romanToInt(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }

        int result = 0;
        for (int i = 0; i < s.length(); i++) {
            int currentVal = getValue(s.charAt(i));

            if (i < s.length() - 1) {
                int nextVal = getValue(s.charAt(i + 1));
                if (currentVal < nextVal) {
                    // 表示为特殊情况，需要减去当前的I、X、C
                    result -= currentVal;
                } else {
                    // 普通情况，直接累加
                    result += currentVal;
                }
            } else {
                result += currentVal;
            }
        }

        // O(n)
        return result;
    }

    private static int getValue(char c) {
        switch (c) {
            case 'I':
                return 1;
            case 'V':
                return 5;
            case 'X':
                return 10;
            case 'L':
                return 50;
            case 'C':
                return 100;
            case 'D':
                return 500;
            case 'M':
                return 1000;
            default:
                return 0;
        }
    }

    public static void main(String[] args) {
        String s1 = "III";
        String s2 = "IV";
        String s3 = "IX";
        String s4 = "LVIII";
        String s5 = "MCMXCIV";

        System.out.println("Test Case 1: " + romanToInt(s1)); // Output: 3
        System.out.println("Test Case 2: " + romanToInt(s2)); // Output: 4
        System.out.println("Test Case 3: " + romanToInt(s3)); // Output: 9
        System.out.println("Test Case 4: " + romanToInt(s4)); // Output: 58
        System.out.println("Test Case 5: " + romanToInt(s5)); // Output: 1994
    }
}

12. 整数转罗马数字 <medium> 贪心

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/*罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

        字符          数值
        I             1
        V             5
        X             10
        L             50
        C             100
        D             500
        M             1000
        例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

        通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

        I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
        X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
        C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
        给你一个整数，将其转为罗马数字。



        示例 1:

        输入: num = 3
        输出: "III"
        示例 2:

        输入: num = 4
        输出: "IV"
        示例 3:

        输入: num = 9
        输出: "IX"
        示例 4:

        输入: num = 58
        输出: "LVIII"
        解释: L = 50, V = 5, III = 3.
        示例 5:

        输入: num = 1994
        输出: "MCMXCIV"
        解释: M = 1000, CM = 900, XC = 90, IV = 4.


        提示：

        1 <= num <= 3999*/
public class IntegerToRoman12 {
    public static String intToRoman(int num) {
        // 通过一个映射表，将数字和罗马数字对应起来，然后从高位到低位按照规则逐步构造出对应的罗马数字
        //TreeMap<Integer, String> romanMap = new TreeMap<>();
        //romanMap.put(1, "I");
        //romanMap.put(4, "IV");
        //romanMap.put(5, "V");
        //romanMap.put(9, "IX");
        //romanMap.put(10, "X");
        //romanMap.put(40, "XL");
        //romanMap.put(50, "L");
        //romanMap.put(90, "XC");
        //romanMap.put(100, "C");
        //romanMap.put(400, "CD");
        //romanMap.put(500, "D");
        //romanMap.put(900, "CM");
        //romanMap.put(1000, "M");
        //
        //int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        //
        //StringBuilder result = new StringBuilder();
        //for (int value : values) {
        //    while (num >= value) {
        //        result.append(romanMap.get(value));
        //        num -= value;
        //    }
        //}
        //
        //// O(1)
        //return result.toString();

        // 可以采用贪心算法的思路，使用两个数组来存储罗马数字和对应的整数值，然后在循环中不断减去最大的值，将对应的罗马数字拼接起来。
        String[] romanSymbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};

        StringBuilder result = new StringBuilder();
        int i = 0;

        while (num > 0) {
            while (num >= values[i]) {
                result.append(romanSymbols[i]);
                num -= values[i];
            }
            i++;
        }

        return result.toString();
    }

    public static void main(String[] args) {
        int num1 = 3;
        int num2 = 4;
        int num3 = 9;
        int num4 = 58;
        int num5 = 1994;

        System.out.println("Test Case 1: " + intToRoman(num1)); // Output: "III"
        System.out.println("Test Case 2: " + intToRoman(num2)); // Output: "IV"
        System.out.println("Test Case 3: " + intToRoman(num3)); // Output: "IX"
        System.out.println("Test Case 4: " + intToRoman(num4)); // Output: "LVIII"
        System.out.println("Test Case 5: " + intToRoman(num5)); // Output: "MCMXCIV"
    }
}

58. 最后一个单词的长度 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

        单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。



        示例 1：

        输入：s = "Hello World"
        输出：5
        解释：最后一个单词是“World”，长度为5。
        示例 2：

        输入：s = "   fly me   to   the moon  "
        输出：4
        解释：最后一个单词是“moon”，长度为4。
        示例 3：

        输入：s = "luffy is still joyboy"
        输出：6
        解释：最后一个单词是长度为6的“joyboy”。


        提示：

        1 <= s.length <= 104
        s 仅有英文字母和空格 ' ' 组成
        s 中至少存在一个单词*/
public class LengthOfLastWord58 {
    public static int lengthOfLastWord(String s) {
        int length = 0;
        for (int i = s.length() - 1;i > - 1;i--) {
            if (' ' != s.charAt(i)) {
                length++;
            } else if (length > 0) {
                return length;
            }
        }
        return length;
    }
}

14. 最长公共前缀 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*编写一个函数来查找字符串数组中的最长公共前缀。

        如果不存在公共前缀，返回空字符串 ""。



        示例 1：

        输入：strs = ["flower","flow","flight"]
        输出："fl"
        示例 2：

        输入：strs = ["dog","racecar","car"]
        输出：""
        解释：输入不存在公共前缀。


        提示：

        1 <= strs.length <= 200
        0 <= strs[i].length <= 200
        strs[i] 仅由小写英文字母组成*/
public class LongestCommonPrefix14 {
    public static String longestCommonPrefix(String[] strs) {
        // 可以采用横向比较的方法
        if (strs == null || strs.length == 0) {
            return "";
        }

        // 第一个字符串设为最长公共前缀，然后逐个与后面的字符串进行比较
        String prefix = strs[0];
        for (int i = 1; i < strs.length; i++) {
            while (strs[i].indexOf(prefix) != 0) {
                prefix = prefix.substring(0, prefix.length() - 1);
                if (prefix.isEmpty()) {
                    return "";
                }
            }
        }

        // 这个算法的时间复杂度是 O(nm)，其中 n 是字符串数组的长度，m 是字符串数组中的字符串的平均长度
        return prefix;
    }

    public static void main(String[] args) {
        String[] test1 = {"flower", "flow", "flight"};
        String[] test2 = {"dog", "racecar", "car"};

        System.out.println("Test Case 1: " + longestCommonPrefix(test1)); // Output: "fl"
        System.out.println("Test Case 2: " + longestCommonPrefix(test2)); // Output: ""
    }
}

151. 反转字符串中的单词 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/*给你一个字符串 s ，请你反转字符串中 单词 的顺序。

        单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

        返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

        注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。



        示例 1：

        输入：s = "the sky is blue"
        输出："blue is sky the"
        示例 2：

        输入：s = "  hello world  "
        输出："world hello"
        解释：反转后的字符串中不能存在前导空格和尾随空格。
        示例 3：

        输入：s = "a good   example"
        输出："example good a"
        解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。


        提示：

        1 <= s.length <= 104
        s 包含英文大小写字母、数字和空格 ' '
        s 中 至少存在一个 单词

        进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。*/
public class ReverseWordsInAString151 {
    public static String reverseWords(String s) {
        //// 去除字符串首尾空格，并用空格分割成单词数组
        //String[] words = s.trim().split("\\s+");
        //StringBuilder result = new StringBuilder();
        //
        //// 从后往前拼接单词
        //for (int i = words.length - 1; i >= 0; i--) {
        //    result.append(words[i]).append(" ");
        //}
        //
        //// 删除最后一个多余的空格
        //return result.toString().trim();

        if (s == null || s.length() == 0) {
            return "";
        }

        char[] str = s.toCharArray();
        int start = s.length() - 1;
        int end = s.length();

        StringBuilder result = new StringBuilder();

        // 以从字符串末尾开始遍历，找到每个单词的起始和结束位置，然后将其拼接到结果字符串上
        while (start >= 0) {
            if (str[start] == ' ') {
                end = start;
            } else if (start == 0 || str[start - 1] == ' ') {
                if (result.length() != 0) {
                    result.append(" ");
                }
                result.append(s, start, end);
            }
            start--;
        }

        return result.toString();
    }

    public static void main(String[] args) {
        String test1 = "the sky is blue";
        String test2 = "  hello world  ";
        String test3 = "a good   example";

        System.out.println("Test Case 1: " + reverseWords(test1)); // Output: "blue is sky the"
        System.out.println("Test Case 2: " + reverseWords(test2)); // Output: "world hello"
        System.out.println("Test Case 3: " + reverseWords(test3)); // Output: "example good a"
    }
}

6. N 字形变换 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/*将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

        比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：

        P   A   H   N
        A P L S I I G
        Y   I   R
        之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。

        请你实现这个将字符串进行指定行数变换的函数：

        string convert(string s, int numRows);


        示例 1：

        输入：s = "PAYPALISHIRING", numRows = 3
        输出："PAHNAPLSIIGYIR"
        示例 2：
        输入：s = "PAYPALISHIRING", numRows = 4
        输出："PINALSIGYAHRPI"
        解释：
        P     I    N
        A   L S  I G
        Y A   H R
        P     I
        示例 3：

        输入：s = "A", numRows = 1
        输出："A"


        提示：

        1 <= s.length <= 1000
        s 由英文字母（小写和大写）、',' 和 '.' 组成
        1 <= numRows <= 1000*/
public class ZigzagConversion6 {
    public static String convert(String s, int numRows) {
        if (numRows == 1 || s.length() <= numRows) {
            return s;
        }

        // 定义 numRows 个字符串来存储 Z 字形中的每一行
        StringBuilder[] rows = new StringBuilder[numRows];
        for (int i = 0; i < numRows; i++) {
            rows[i] = new StringBuilder();
        }

        int row = 0;
        boolean goingDown = false;

        // 然后遍历输入字符串，根据当前字符应该位于 Z 字形的哪一行，将字符添加到对应的行中
        for (char c : s.toCharArray()) {
            // 将当前 row 对应字符 c 添加到字符串构建器中
            rows[row].append(c);
            // 判断当前字符是否位于 Z 字形的顶部或底部。若是，则需要改变遍历方向，即从上往下或从下往上
            if (row == 0 || row == numRows - 1) {
                goingDown = !goingDown;
            }
            // 根据 goingDown 的值，确定当前字符在 Z 字形中下一个位置的行数，若 goingDown 为 true，则向下移动一行；否则向上移动一行
            row += goingDown ? 1 : -1;
        }

        // 最后按照行的顺序将这些行连接起来，就是最终的结果。
        StringBuilder result = new StringBuilder();
        for (StringBuilder stringBuilder : rows) {
            result.append(stringBuilder);
        }

        // O(n)
        return result.toString();
    }

    public static void main(String[] args) {
        String test1 = "PAYPALISHIRING";
        String test2 = "PAYPALISHIRING";
        String test3 = "A";

        System.out.println("Test Case 1: " + convert(test1, 3)); // Output: "PAHNAPLSIIGYIR"
        System.out.println("Test Case 2: " + convert(test2, 4)); // Output: "PINALSIGYAHRPI"
        System.out.println("Test Case 3: " + convert(test3, 1)); // Output: "A"
    }
}

28. 找出字符串中第一个匹配项的下标 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

        示例 1：

        输入：haystack = "sadbutsad", needle = "sad"
        输出：0
        解释："sad" 在下标 0 和 6 处匹配。
        第一个匹配项的下标是 0 ，所以返回 0 。
        示例 2：

        输入：haystack = "leetcode", needle = "leeto"
        输出：-1
        解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。


        提示：

        1 <= haystack.length, needle.length <= 104
        haystack 和 needle 仅由小写英文字符组成*/
public class FindTheIndexOfTheFirstOccurrenceInAString28 {

    public static int strStr(String haystack, String needle) {
        int hayLength = haystack.length();
        int needleLength = needle.length();
        if (needleLength == 0) return 0;
        // 遍历 haystack 字符串并查找 needle 字符串
        for (int i = 0; i <= hayLength - needleLength; i++) {
            if (haystack.charAt(i) == needle.charAt(0)) {
                int j = 0;
                while (j < needleLength && haystack.charAt(i + j) == needle.charAt(j)) {
                    j++;
                }
                if (j == needleLength) {
                    return i;
                }
            }
        }
        // O(n⋅m) O(1)
        return -1;
    }

    public static void main(String[] args) {
        String haystack1 = "sadbutsad";
        String needle1 = "sad";
        System.out.println(strStr(haystack1, needle1)); // 输出: 0

        String haystack2 = "leetcode";
        String needle2 = "leeto";
        System.out.println(strStr(haystack2, needle2)); // 输出: -1
    }
}

68. 文本左右对齐 <hard> 贪心

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/*给定一个单词数组 words 和一个长度 maxWidth ，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。

        你应该使用 “贪心算法” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充，使得每行恰好有 maxWidth 个字符。

        要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。

        文本的最后一行应为左对齐，且单词之间不插入额外的空格。

        注意:

        单词是指由非空格字符组成的字符序列。
        每个单词的长度大于 0，小于等于 maxWidth。
        输入单词数组 words 至少包含一个单词。

        示例 1:

        输入: words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16
        输出:
        [
        "This    is    an",
        "example  of text",
        "justification.  "
        ]
        示例 2:

        输入:words = ["What","must","be","acknowledgment","shall","be"], maxWidth = 16
        输出:
        [
        "What   must   be",
        "acknowledgment  ",
        "shall be        "
        ]
        解释: 注意最后一行的格式应为 "shall be    " 而不是 "shall     be",
        因为最后一行应为左对齐，而不是左右两端对齐。
        第二行同样为左对齐，这是因为这行只包含一个单词。
        示例 3:

        输入:words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"]，maxWidth = 20
        输出:
        [
        "Science  is  what we",
        "understand      well",
        "enough to explain to",
        "a  computer.  Art is",
        "everything  else  we",
        "do                  "
        ]


        提示:

        1 <= words.length <= 300
        1 <= words[i].length <= 20
        words[i] 由小写英文字母和符号组成
        1 <= maxWidth <= 100
        words[i].length <= maxWidth*/
public class TextJustification68 {

    public static List<String> fullJustify(String[] words, int maxWidth) {
        // 贪心算法
        List<String> result = new ArrayList<>();
        // 单词索引
        int index = 0;

        // 遍历单词列表
        while (index < words.length) {
            // 当前行长度
            int lineLength = words[index].length();
            // 下一个单词索引
            int lastWordIndex = index + 1;

            // 每行中尽可能多地放置单词，且不超过最大宽度
            while (lastWordIndex < words.length && lineLength + 1 + words[lastWordIndex].length() <= maxWidth) {
                // 更新当前行长度
                lineLength += 1 + words[lastWordIndex].length();
                // 移至下一个单词
                lastWordIndex++;
            }

            // 使用StringBuilder构建当前行
            StringBuilder builder = new StringBuilder();
            // 当前行单词间隔数
            int diff = lastWordIndex - index - 1;

            if (lastWordIndex == words.length || diff == 0) {
                // 最后一行或只有一个单词的行，用空格补充
                for (int i = index; i < lastWordIndex; i++) {
                    builder.append(words[i]).append(" ");
                }
                builder.deleteCharAt(builder.length() - 1);
                while (builder.length() < maxWidth) {
                    builder.append(" ");
                }
            } else {
                // 平均空格数
                int spaces = (maxWidth - lineLength) / diff;
                // 额外的空格
                int extraSpaces = (maxWidth - lineLength) % diff;

                // 在每个单词之间均匀分配空格
                for (int i = index; i < lastWordIndex - 1; i++) {
                    builder.append(words[i]);
                    for (int j = 0; j <= spaces + (i - index < extraSpaces ? 1 : 0); j++) {
                        builder.append(" ");
                    }
                }
                // 添加最后一个单词
                builder.append(words[lastWordIndex - 1]);
            }

            result.add(builder.toString());
            // 更新单词索引为下一个行的单词索引
            index = lastWordIndex;
        }

        return result;
    }

    public static void main(String[] args) {
        String[] words1 = {"This", "is", "an", "example", "of", "text", "justification."};
        int maxWidth1 = 16;
        System.out.println(fullJustify(words1, maxWidth1));

        String[] words2 = {"What", "must", "be", "acknowledgment", "shall", "be"};
        int maxWidth2 = 16;
        System.out.println(fullJustify(words2, maxWidth2));

        String[] words3 = {"Science", "is", "what", "we", "understand", "well", "enough", "to", "explain", "to", "a", "computer.", "Art", "is", "everything", "else", "we", "do"};
        int maxWidth3 = 20;
        System.out.println(fullJustify(words3, maxWidth3));
    }
}

3.2 双指针 Two Pointers

使用两个指针在一次遍历中解决问题

  1. 对撞指针：从数组两端移动指针，寻找满足条件的元素。如找到两数之和、反转链表、回文判断等
  2. 快慢指针：用两个不同速度的指针遍历，通常用于检测环形链表、寻找中间节点等

125. 验证回文串 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

        字母和数字都属于字母数字字符。

        给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

        示例 1：

        输入: s = "A man, a plan, a canal: Panama"
        输出：true
        解释："amanaplanacanalpanama" 是回文串。
        示例 2：

        输入：s = "race a car"
        输出：false
        解释："raceacar" 不是回文串。
        示例 3：

        输入：s = " "
        输出：true
        解释：在移除非字母数字字符之后，s 是一个空字符串 "" 。
        由于空字符串正着反着读都一样，所以是回文串。


        提示：

        1 <= s.length <= 2 * 105
        s 仅由可打印的 ASCII 字符组成*/
public class ValidPalindrome125 {
    public static boolean isPalindrome(String s) {
        if (s.isEmpty()) return true;
        // 双指针
        int left = 0, right = s.length() - 1;
        while (left < right) {
            // 非字母和数字，直接跳过
            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
                left++;
            }
            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
                right--;
            }
            // 左右指针不相同，直接判定不符
            if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
                return false;
            }
            left++;
            right--;
        }
        // 遍历全部都相等
        // O(n)
        return true;
    }

    public static void main(String[] args) {
        String s1 = "A man, a plan, a canal: Panama";
        System.out.println(isPalindrome(s1)); // Output: true

        String s2 = "race a car";
        System.out.println(isPalindrome(s2)); // Output: false

        String s3 = " ";
        System.out.println(isPalindrome(s3)); // Output: true
    }
}

392. 判断子序列 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/*给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

        字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

        进阶：

        如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

        致谢：

        特别感谢 @pbrother 添加此问题并且创建所有测试用例。



        示例 1：

        输入：s = "abc", t = "ahbgdc"
        输出：true
        示例 2：

        输入：s = "axc", t = "ahbgdc"
        输出：false


        提示：

        0 <= s.length <= 100
        0 <= t.length <= 10^4
        两个字符串都只由小写字符组成。*/
public class IsSubsequence392 {
    public static boolean isSubsequence(String s, String t) {
        int sPointer = 0, tPointer = 0;

        // 循环直到某一个字符串遍历结束
        while (sPointer < s.length() && tPointer < t.length()) {
            // 如果两个字符相等，移动 s 的指针
            if (s.charAt(sPointer) == t.charAt(tPointer)) {
                sPointer++;
            }
            // 不管相等与否，移动 t 的指针
            tPointer++;
        }

        // 如果 s 遍历结束，说明 s 是 t 的子序列
        // O(n)
        return sPointer == s.length();
    }

    public static void main(String[] args) {
        String s1 = "abc", t1 = "ahbgdc";
        System.out.println(isSubsequence(s1, t1)); // Output: true

        String s2 = "axc", t2 = "ahbgdc";
        System.out.println(isSubsequence(s2, t2)); // Output: false
    }
}

167. 两数之和 II - 输入有序数组 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/*给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

        以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

        你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

        你所设计的解决方案必须只使用常量级的额外空间。


        示例 1：

        输入：numbers = [2,7,11,15], target = 9
        输出：[1,2]
        解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
        示例 2：

        输入：numbers = [2,3,4], target = 6
        输出：[1,3]
        解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
        示例 3：

        输入：numbers = [-1,0], target = -1
        输出：[1,2]
        解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。


        提示：

        2 <= numbers.length <= 3 * 104
        -1000 <= numbers[i] <= 1000
        numbers 按 非递减顺序 排列
        -1000 <= target <= 1000
        仅存在一个有效答案*/
public class TwoSumIIInputArrayIsSorted167 {
    public static int[] twoSum(int[] numbers, int target) {
        int left = 0, right = numbers.length - 1;

        while (left < right) {
            int sum = numbers[left] + numbers[right];

            if (sum == target) {
                // 题目要求索引从 1 开始，所以加 1 返回
                return new int[]{left + 1, right + 1};
            } else if (sum < target) {
                // 如果和小于目标值，增加左指针以增加和
                left++;
            } else {
                // 如果和大于目标值，减少右指针以减少和
                right--;
            }
        }

        // 找不到符合条件的数对
        // O(n)
        return new int[]{-1, -1};
    }

    public static void main(String[] args) {
        int[] numbers1 = {2, 7, 11, 15};
        int target1 = 9;
        int[] result1 = twoSum(numbers1, target1);
        System.out.println("Result 1: [" + result1[0] + ", " + result1[1] + "]");

        int[] numbers2 = {2, 3, 4};
        int target2 = 6;
        int[] result2 = twoSum(numbers2, target2);
        System.out.println("Result 2: [" + result2[0] + ", " + result2[1] + "]");

        int[] numbers3 = {-1, 0};
        int target3 = -1;
        int[] result3 = twoSum(numbers3, target3);
        System.out.println("Result 3: [" + result3[0] + ", " + result3[1] + "]");
    }
}

11. 盛最多水的容器 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/*给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

        找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

        返回容器可以储存的最大水量。

        说明：你不能倾斜容器。

        示例 1：


        输入：[1,8,6,2,5,4,8,3,7]
        输出：49
        解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
        示例 2：

        输入：height = [1,1]
        输出：1

        提示：

        n == height.length
        2 <= n <= 105
        0 <= height[i] <= 104*/
public class ContainerWithMostWater11 {

    public static int maxArea(int[] height) {
        int maxArea = 0;
        int left = 0, right = height.length - 1;

        while (left < right) {
            int currentArea = Math.min(height[left], height[right]) * (right - left);
            // 记录历史最大面积
            maxArea = Math.max(maxArea, currentArea);

            // 哪边低移动哪边
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }

        // O(n)
        return maxArea;
    }

    public static void main(String[] args) {
        int[] heights1 = {1, 8, 6, 2, 5, 4, 8, 3, 7};
        System.out.println("Max area for heights1: " + maxArea(heights1));

        int[] heights2 = {1, 1};
        System.out.println("Max area for heights2: " + maxArea(heights2));

        int[] heights3 = {1, 2, 1};
        System.out.println("Max area for heights3: " + maxArea(heights3));
    }

}

15. 三数之和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/*给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

        你返回所有和为 0 且不重复的三元组。

        注意：答案中不可以包含重复的三元组。


        示例 1：

        输入：nums = [-1,0,1,2,-1,-4]
        输出：[[-1,-1,2],[-1,0,1]]
        解释：
        nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
        nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
        nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
        不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
        注意，输出的顺序和三元组的顺序并不重要。
        示例 2：

        输入：nums = [0,1,1]
        输出：[]
        解释：唯一可能的三元组和不为 0 。
        示例 3：

        输入：nums = [0,0,0]
        输出：[[0,0,0]]
        解释：唯一可能的三元组和为 0 。


        提示：

        3 <= nums.length <= 3000
        -105 <= nums[i] <= 105*/
public class ThreeSum15 {

    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        // 先排序
        Arrays.sort(nums);

        // 外层遍历固定一个数
        for (int i = 0; i < nums.length - 2; i++) {
            // 跳过重复元素
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            // 里层遍历，用双指针找另外两个数
            int left = i + 1;
            int right = nums.length - 1;

            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum == 0) {
                    // 命中
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));

                    // 跳过重复元素
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }

                    left++;
                    right--;
                } else if (sum < 0) {
                    // 和小于0，则往右移
                    left++;
                } else {
                    right--;
                }
            }
        }
        // O(n^2)，空间复杂度为 O(log n) 到 O(n)

        return result;
    }

    public static void main(String[] args) {
        ThreeSum15 solution = new ThreeSum15();
        int[] nums1 = {-1, 0, 1, 2, -1, -4};
        System.out.println(solution.threeSum(nums1)); // Output: [[-1, -1, 2], [-1, 0, 1]]

        int[] nums2 = {0, 1, 1};
        System.out.println(solution.threeSum(nums2)); // Output: []

        int[] nums3 = {0, 0, 0};
        System.out.println(solution.threeSum(nums3)); // Output: [[0, 0, 0]]
    }
}

3.3 滑动窗口 Sliding Window

（双指针变形）使用两个指针定义一个窗口，通过移动右指针扩大窗口，移动左指针缩小窗口

  1. 找到满足条件的数组（字符串）的最大/最小子数组（子串）
  2. 给定数组移动固定大小窗口，查找其中的固定值

209. 长度最小的子数组 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/*给定一个含有 n 个正整数的数组和一个正整数 target 。

        找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

        示例 1：

        输入：target = 7, nums = [2,3,1,2,4,3]
        输出：2
        解释：子数组 [4,3] 是该条件下的长度最小的子数组。
        示例 2：

        输入：target = 4, nums = [1,4,4]
        输出：1
        示例 3：

        输入：target = 11, nums = [1,1,1,1,1,1,1,1]
        输出：0


        提示：

        1 <= target <= 10^9
        1 <= nums.length <= 10^5
        1 <= nums[i] <= 10^5

        进阶：

        如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。*/
public class MinimumSizeSubarraySum209 {

    public int minSubArrayLen(int target, int[] nums) {
        // 双指针，left和right分别表示滑动窗口的边界
        //int left = 0;
        //int sum = 0;
        //int minLength = Integer.MAX_VALUE;
        //
        //for (int right = 0; right < nums.length; right++) {
        //    // 先连续相加，直到窗口内的总和大于等于目标值
        //    sum += nums[right];
        //
        //    // 然后记录窗口的大小，并缩小窗口
        //    while (sum >= target) {
        //        minLength = Math.min(minLength, right - left + 1);
        //        // 减去左边界的元素看看是否仍然符合要求
        //        sum -= nums[left];
        //        left++;
        //    }
        //    // sum减到不再大于目标值时，再继续向右移动右边界
        //}
        //
        ////  O(n)
        //return minLength == Integer.MAX_VALUE ? 0 : minLength;

        // 2.使用二分查找和前缀和
        int n = nums.length;
        if (n == 0) return 0;

        // 维护一个前缀和数组
        int[] prefixSum = new int[n + 1];
        // 遍历一次数组，每个元素都是前面元素的和
        for (int i = 1; i <= n; i++) {
            prefixSum[i] = prefixSum[i - 1] + nums[i - 1];
        }

        int minLen = Integer.MAX_VALUE;
        // 遍历前缀和数组
        for (int i = 1; i <= n; i++) {
            int left = 0, right = i - 1;

            // 通过二分查找在前面已计算的前缀和中寻找一个位置，使得两个前缀和之差满足条件
            while (left <= right) {
                int mid = left + (right - left) / 2;
                int sum = prefixSum[i] - prefixSum[mid];

                if (sum >= target) {
                    minLen = Math.min(minLen, i - mid);
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }

        // O(n log(n))
        return minLen == Integer.MAX_VALUE ? 0 : minLen;
    }

    public static void main(String[] args) {
        MinimumSizeSubarraySum209 solution = new MinimumSizeSubarraySum209();
        int[] nums1 = {2, 3, 1, 2, 4, 3};
        int[] nums2 = {1, 4, 4};
        int[] nums3 = {1, 1, 1, 1, 1, 1, 1, 1};
        int target1 = 7;
        int target2 = 4;
        int target3 = 11;

        System.out.println(solution.minSubArrayLen(target1, nums1)); // Output: 2
        System.out.println(solution.minSubArrayLen(target2, nums2)); // Output: 1
        System.out.println(solution.minSubArrayLen(target3, nums3)); // Output: 0
    }
}

3. 无重复字符的最长子串 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/*给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

        示例 1:

        输入: s = "abcabcbb"
        输出: 3
        解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
        示例 2:

        输入: s = "bbbbb"
        输出: 1
        解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
        示例 3:

        输入: s = "pwwkew"
        输出: 3
        解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
        请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。


        提示：

        0 <= s.length <= 5 * 104
        s 由英文字母、数字、符号和空格组成*/
public class LongestSubstringWithoutRepeatingCharacters3 {

    public static int lengthOfLongestSubstring(String s) {
        int n = s.length();
        // 滑动窗口左右边界
        int left = 0, right = 0;
        int maxLen = 0;
        // 通过哈希集合来存放窗口内的元素
        HashSet<Character> set = new HashSet<>();

        while (right < n) {
            if (!set.contains(s.charAt(right))) {
                // 右指针右移，将元素加入set
                set.add(s.charAt(right++));
                // 更新最大长度
                maxLen = Math.max(maxLen, set.size());
            } else {
                // 右指针指到重复元素，尝试移除左指针元素直到清除干净重复元素
                set.remove(s.charAt(left++));
            }
        }
        // O(n)
        return maxLen;
    }

    public static void main(String[] args) {
        String s1 = "abcabcbb";
        String s2 = "bbbbb";
        String s3 = "pwwkew";

        System.out.println("Length of longest substring without repeating characters in s1: " + lengthOfLongestSubstring(s1)); // Output: 3
        System.out.println("Length of longest substring without repeating characters in s2: " + lengthOfLongestSubstring(s2)); // Output: 1
        System.out.println("Length of longest substring without repeating characters in s3: " + lengthOfLongestSubstring(s3)); // Output: 3
    }
}

30. 串联所有单词的子串 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/*给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

        s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。

        例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。
        返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。



        示例 1：

        输入：s = "barfoothefoobarman", words = ["foo","bar"]
        输出：[0,9]
        解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
        子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
        子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
        输出顺序无关紧要。返回 [9,0] 也是可以的。
        示例 2：

        输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
        输出：[]
        解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
        s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
        所以我们返回一个空数组。
        示例 3：

        输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
        输出：[6,9,12]
        解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
        子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
        子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
        子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。


        提示：

        1 <= s.length <= 10^4
        1 <= words.length <= 5000
        1 <= words[i].length <= 30
        words[i] 和 s 由小写英文字母组成*/
public class SubstringWithConcatenationOfAllWords30 {

    public static List<Integer> findSubstring(String s, String[] words) {
/*        List<Integer> result = new ArrayList<>();
        if (s.isEmpty() || words.length == 0) return result;

        int wordLen = words[0].length();
        int wordCount = words.length;
        int totalLen = wordLen * wordCount;
        // 哈希表存储拆分的words每个单词和出现次数，已知word可以重复
        HashMap<String, Integer> wordCountMap = new HashMap<>();

        // 初始化哈希表
        for (String word : words) {
            wordCountMap.put(word, wordCountMap.getOrDefault(word, 0) + 1);
        }

        // 遍历字符串
        for (int i = 0; i <= s.length() - totalLen; i++) {
            // 存储当前子串中出现的单词和次数
            HashMap<String, Integer> wordSeen = new HashMap<>();
            // j指针右移，命中一个单词则记录一个，没命中或者出现次数超出则不符合
            int j = 0;
            while (j < wordCount) {
                // 拆出单词
                String word = s.substring(i + j * wordLen, i + (j + 1) * wordLen);
                if (wordCountMap.containsKey(word)) {
                    // 记录出现次数
                    wordSeen.put(word, wordSeen.getOrDefault(word, 0) + 1);
                    if (wordSeen.get(word) > wordCountMap.getOrDefault(word, 0)) {
                        break;
                    }
                } else {
                    break;
                }
                j++;
            }
            // 循环结束刚好符合，则记录起始下标
            if (j == wordCount) {
                result.add(i);
            }
        }
        // O(n * m) O(m)
        return result;*/

        List<Integer> result = new ArrayList<>();
        if (s.isEmpty() || words.length == 0) return result;

        int wordLen = words[0].length();
        int wordCount = words.length;
        // 哈希表存储拆分的words每个单词和出现次数，已知word可以重复
        HashMap<String, Integer> wordCountMap = new HashMap<>();
        for (String word : words) {
            wordCountMap.put(word, wordCountMap.getOrDefault(word, 0) + 1);
        }

        for (int i = 0; i < wordLen; i++) {
            int left = i, right = i, count = 0;
            // 存储当前子串中出现的单词和次数
            HashMap<String, Integer> wordSeen = new HashMap<>();
            // 通过滑动窗口
            while (right + wordLen <= s.length()) {
                String word = s.substring(right, right + wordLen);
                right += wordLen;

                if (wordCountMap.containsKey(word)) {
                    wordSeen.put(word, wordSeen.getOrDefault(word, 0) + 1);
                    count++;

                    // 当前单词出现次数已超过，则移动左指针，直到满足条件
                    while (wordSeen.getOrDefault(word, 0) > wordCountMap.getOrDefault(word, 0)) {
                        String leftWord = s.substring(left, left + wordLen);
                        count--;
                        wordSeen.put(leftWord, wordSeen.get(leftWord) - 1);
                        left += wordLen;
                    }

                    if (count == wordCount) {
                        result.add(left);
                    }
                } else {
                    wordSeen.clear();
                    count = 0;
                    left = right;
                }
            }
        }
        // O(n) O(m)
        return result;
    }

    public static void main(String[] args) {
        String s1 = "barfoothefoobarman";
        String[] words1 = {"foo","bar"};

        String s2 = "wordgoodgoodgoodbestword";
        String[] words2 = {"word","good","best","word"};

        String s3 = "barfoofoobarthefoobarman";
        String[] words3 = {"bar","foo","the"};

        System.out.println("Substring indices in s1: " + findSubstring(s1, words1)); // Output: [0, 9]
        System.out.println("Substring indices in s2: " + findSubstring(s2, words2)); // Output: []
        System.out.println("Substring indices in s3: " + findSubstring(s3, words3)); // Output: [6, 9, 12]
    }
}

76. 最小覆盖子串 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

        注意：

        对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
        如果 s 中存在这样的子串，我们保证它是唯一的答案。


        示例 1：

        输入：s = "ADOBECODEBANC", t = "ABC"
        输出："BANC"
        解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
        示例 2：

        输入：s = "a", t = "a"
        输出："a"
        解释：整个字符串 s 是最小覆盖子串。
        示例 3:

        输入: s = "a", t = "aa"
        输出: ""
        解释: t 中两个字符 'a' 均应包含在 s 的子串中，
        因此没有符合条件的子字符串，返回空字符串。


        提示：

        m == s.length
        n == t.length
        1 <= m, n <= 105
        s 和 t 由英文字母组成*/
public class MinimumWindowSubstring76 {
    public static String minWindow(String s, String t) {
        if (s.length() == 0 || t.length() == 0 || s.length() < t.length()) return "";
        // 拆分字符串t
        Map<Character, Integer> countMap = new HashMap<>();
        ////可以优化Map为集合来提高运行速度
        // int[] tCount = new int[128];
        for (char ch : t.toCharArray()) {
            countMap.put(ch, countMap.getOrDefault(ch, 0) + 1);
        }

        int left = 0, right = 0;
        int minLen = Integer.MAX_VALUE;
        int minStart = 0;
        int required = countMap.size();
        int formed = 0;
        Map<Character, Integer> windowMap = new HashMap<>();
        // int[] windowCount = new int[128];
        // 使用右边界指针遍历字符串s
        while (right < s.length()) {
            char ch = s.charAt(right);
            // windowCount[ch]++;
            windowMap.put(ch, windowMap.getOrDefault(ch, 0) + 1);

            // if (tCount[ch] > 0 && windowCount[ch] <= tCount[ch]) {
            if (countMap.containsKey(ch) && windowMap.get(ch).intValue() == countMap.get(ch).intValue()) {
                // 当前字符已全部命中
                formed++;
            }

            // 当字符全部命中后，开始移动左指针尝试删除
            while (left <= right && formed == required) {
                ch = s.charAt(left);

                // 先更新当前最短字符串长度
                if (minLen > right - left + 1) {
                    minLen = right - left + 1;
                    minStart = left;
                }

                //windowCount[ch]--;
                //if (tCount[ch] > 0 && windowCount[ch] < tCount[ch]) {
                // 移除左边界元素
                windowMap.put(ch, windowMap.get(ch) - 1);
                if (countMap.containsKey(ch) && windowMap.get(ch) < countMap.get(ch)) {
                    // 若删错元素，则formed-1，继续右移右边界
                    formed--;
                }

                // 删除成功，继续移动左边界
                left++;
            }
            right++;
        }

        // O(n) O(m + n)
        return minLen == Integer.MAX_VALUE ? "" : s.substring(minStart, minStart + minLen);
    }

    public static void main(String[] args) {
        String s1 = "ADOBECODEBANC";
        String t1 = "ABC";
        System.out.println(minWindow(s1, t1)); // Output: "BANC"

        String s2 = "a";
        String t2 = "a";
        System.out.println(minWindow(s2, t2)); // Output: "a"

        String s3 = "a";
        String t3 = "aa";
        System.out.println(minWindow(s3, t3)); // Output: ""
    }
}

3.4 矩阵 Matrix

多维数组

36. 有效的数独 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/*请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

        数字 1-9 在每一行只能出现一次。
        数字 1-9 在每一列只能出现一次。
        数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）


        注意：

        一个有效的数独（部分已被填充）不一定是可解的。
        只需要根据以上规则，验证已经填入的数字是否有效即可。
        空白格用 '.' 表示。


        示例 1：


        输入：board =
        [["5","3",".",".","7",".",".",".","."]
        ,["6",".",".","1","9","5",".",".","."]
        ,[".","9","8",".",".",".",".","6","."]
        ,["8",".",".",".","6",".",".",".","3"]
        ,["4",".",".","8",".","3",".",".","1"]
        ,["7",".",".",".","2",".",".",".","6"]
        ,[".","6",".",".",".",".","2","8","."]
        ,[".",".",".","4","1","9",".",".","5"]
        ,[".",".",".",".","8",".",".","7","9"]]
        输出：true
        示例 2：

        输入：board =
        [["8","3",".",".","7",".",".",".","."]
        ,["6",".",".","1","9","5",".",".","."]
        ,[".","9","8",".",".",".",".","6","."]
        ,["8",".",".",".","6",".",".",".","3"]
        ,["4",".",".","8",".","3",".",".","1"]
        ,["7",".",".",".","2",".",".",".","6"]
        ,[".","6",".",".",".",".","2","8","."]
        ,[".",".",".","4","1","9",".",".","5"]
        ,[".",".",".",".","8",".",".","7","9"]]
        输出：false
        解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。


        提示：

        board.length == 9
        board[i].length == 9
        board[i][j] 是一位数字（1-9）或者 '.'*/
public class ValidSudoku36 {


    public static boolean isValidSudoku(char[][] board) {

        if (board == null || board.length != 9 || board[0].length != 9) {
            return false;
        }

        for (int i = 0; i < 9; i++) {
            // 分别用数组记录数字是否出现过
            boolean[] rowSeen = new boolean[9];
            boolean[] colSeen = new boolean[9];

            for (int j = 0; j < 9; j++) {
                if (board[i][j] != '.') {
                    // 行检测
                    int num = board[i][j] - '1';
                    if (rowSeen[num]) {
                        // 有重复元素
                        return false;
                    }
                    rowSeen[num] = true;
                }

                if (board[j][i] != '.') {
                    // 列检测
                    int num = board[j][i] - '1';
                    if (colSeen[num]) {
                        // 有重复元素
                        return false;
                    }
                    colSeen[num] = true;
                }
            }
        }

        // 检查 3x3 宫，遍历9个子网格并使用一个数组 seen 来记录数字的出现情况
        for (int block = 0; block < 9; block++) {
            boolean[] seen = new boolean[9];
            // 行索引和列索引要错位，从而能
            for (int i = block / 3 * 3; i < block / 3 * 3 + 3; i++) {
                // 行循环，除法，000,111,222，最后乘以3
                for (int j = block % 3 * 3; j < block % 3 * 3 + 3; j++) {
                    // 列循环，求余，012,012,012，最后乘以3
                    if (board[i][j] != '.') {
                        int num = board[i][j] - '1';
                        if (seen[num]) {
                            return false;
                        }
                        seen[num] = true;
                    }
                }
            }
        }

        return true;
    }

    public static void main(String[] args) {
        char[][] board1 = {
                {'5','3','.','.','7','.','.','.','.'},
                {'6','.','.','1','9','5','.','.','.'},
                {'.','9','8','.','.','.','.','6','.'},
                {'8','.','.','.','6','.','.','.','3'},
                {'4','.','.','8','.','3','.','.','1'},
                {'7','.','.','.','2','.','.','.','6'},
                {'.','6','.','.','.','.','2','8','.'},
                {'.','.','.','4','1','9','.','.','5'},
                {'.','.','.','.','8','.','.','7','9'}
        };
        System.out.println(isValidSudoku(board1)); // Output: true

        char[][] board2 = {
                {'8','3','.','.','7','.','.','.','.'},
                {'6','.','.','1','9','5','.','.','.'},
                {'.','9','8','.','.','.','.','6','.'},
                {'8','.','.','.','6','.','.','.','3'},
                {'4','.','.','8','.','3','.','.','1'},
                {'7','.','.','.','2','.','.','.','6'},
                {'.','6','.','.','.','.','2','8','.'},
                {'.','.','.','4','1','9','.','.','5'},
                {'.','.','.','.','8','.','.','7','9'}
        };
        System.out.println(isValidSudoku(board2)); // Output: false
    }
}

54. 螺旋矩阵 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/*给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

        示例 1：

        输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
        输出：[1,2,3,6,9,8,7,4,5]

        示例 2：

        输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
        输出：[1,2,3,4,8,12,11,10,9,5,6,7]

        提示：

        m == matrix.length
        n == matrix[i].length
        1 <= m, n <= 10
        -100 <= matrix[i][j] <= 100*/
public class SpiralMatrix54 {

    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0) return result;

        int rows = matrix.length;
        int cols = matrix[0].length;

        // 定义边界指针
        int left = 0, right = cols - 1;
        int top = 0, bottom = rows - 1;

        while (left <= right && top <= bottom) {
            // 右移
            for (int i = left; i <= right; i++) {
                result.add(matrix[top][i]);
            }

            // 下移
            for (int i = top + 1; i <= bottom; i++) {
                result.add(matrix[i][right]);
            }

            // 左移，除非上下指针相碰
            if (top < bottom) {
                for (int i = right - 1; i >= left; i--) {
                    result.add(matrix[bottom][i]);
                }
            }

            // 上移，除非左右指针相碰
            if (left < right) {
                for (int i = bottom - 1; i > top; i--) {
                    result.add(matrix[i][left]);
                }
            }

            // 移完一圈后，更新指针边界，左上+1，右下-1
            left++;
            right--;
            top++;
            bottom--;
        }
        // O(m*n)
        return result;
    }

    public static void main(String[] args) {
        int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] matrix2 = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

        System.out.println(spiralOrder(matrix1)); // Output: [1, 2, 3, 6, 9, 8, 7, 4, 5]
        System.out.println(spiralOrder(matrix2)); // Output: [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]
    }

}

48. 旋转图像 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

        你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

        示例 1：

        输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
        输出：[[7,4,1],[8,5,2],[9,6,3]]
        示例 2：


        输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
        输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]


        提示：

        n == matrix.length == matrix[i].length
        1 <= n <= 20
        -1000 <= matrix[i][j] <= 1000*/
public class RotateImage48 {

    public static void rotate(int[][] matrix) {
        int n = matrix.length;
        for (int i = 0; i < n / 2; i++) {
            // i表示层数
            for (int j = i; j < n - i - 1; j++) {
                // j通过四次交换操作旋转该层的四个边上的元素
                int temp = matrix[i][j];
                // 从上层的左上角开始，将四个边上的元素依次移到下一个位置
                // 如4X4 00-30 30-33 33-03 03-00
                // 01-20 20-32 32-13 13 01
                matrix[i][j] = matrix[n - j - 1][i];
                matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];
                matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
                matrix[j][n - i - 1] = temp;
            }
        }
        // O(n^2)
    }

    public static void main(String[] args) {
        int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] matrix2 = {{5, 1, 9, 11}, {2, 4, 8, 10}, {13, 3, 6, 7}, {15, 14, 12, 16}};

        rotate(matrix1);
        rotate(matrix2);

        printMatrix(matrix1); // Output: [[7, 4, 1], [8, 5, 2], [9, 6, 3]]
        printMatrix(matrix2); // Output: [[15, 13, 2, 5], [14, 3, 4, 1], [12, 6, 8, 9], [16, 7, 10, 11]]
    }

    private static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

73. 矩阵置零 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/*给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。

        示例 1：

        输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
        输出：[[1,0,1],[0,0,0],[1,0,1]]

        示例 2：

        输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
        输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

        提示：

        m == matrix.length
        n == matrix[0].length
        1 <= m, n <= 200
        -2^31 <= matrix[i][j] <= 2^31 - 1*/
public class SetMatrixZeroes73 {
    public static void setZeroes(int[][] matrix) {
        // 首行和首列先不处理，作为标记行
        int m = matrix.length;
        int n = matrix[0].length;
        boolean firstRowHasZero = false;
        boolean firstColHasZero = false;

        // 检查首行是否需要为0
        for (int i = 0; i < n; i++) {
            if (matrix[0][i] == 0) {
                firstRowHasZero = true;
                break;
            }
        }

        // 检查首列是否需要为0
        for (int i = 0; i < m; i++) {
            if (matrix[i][0] == 0) {
                firstColHasZero = true;
                break;
            }
        }

        // 标记零的边界点
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 从(1, 1)开始寻找0的坐标，找到后将上左两侧标记为0
                if (matrix[i][j] == 0) {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }

        // 如果两侧有任意点为0则将对应点也置0
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }

        // 最后处理首行和首列
        if (firstRowHasZero) {
            for (int i = 0; i < n; i++) {
                matrix[0][i] = 0;
            }
        }

        if (firstColHasZero) {
            for (int i = 0; i < m; i++) {
                matrix[i][0] = 0;
            }
        }
    }

    public static void main(String[] args) {
        int[][] matrix1 = {{1, 1, 1}, {1, 0, 1}, {1, 1, 1}};
        setZeroes(matrix1);
        System.out.println(Arrays.deepToString(matrix1));

        int[][] matrix2 = {{0, 1, 2, 0}, {3, 4, 5, 2}, {1, 3, 1, 5}};
        setZeroes(matrix2);
        System.out.println(Arrays.deepToString(matrix2));

    }
}

289. 生命游戏 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/*根据 百度百科 ， 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。

        给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

        如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
        如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
        如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
        如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
        下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。



        示例 1：


        输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
        输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
        示例 2：


        输入：board = [[1,1],[1,0]]
        输出：[[1,1],[1,1]]


        提示：

        m == board.length
        n == board[i].length
        1 <= m, n <= 25
        board[i][j] 为 0 或 1


        进阶：

        你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
        本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？*/
public class GameOfLife289 {
    public void gameOfLife(int[][] board) {
        // directions数组来代表细胞周围的八个方向，使用-1和2分别表示中间状态：活转死，死转活。
        int m = board.length;
        int n = board[0].length;
        int[][] directions = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};

        // 遍历每个细胞，计算其周围活细胞的数量
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 统计周围活细胞
                int liveNeighbors = 0;

                // 查看其8个方向的活细胞数量
                for (int[] dir : directions) {
                    int newRow = i + dir[0];
                    int newCol = j + dir[1];

                    // 新的行列在矩阵内，并且为活细胞，则统计+1
                    if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n
                            && (board[newRow][newCol] == 1 || board[newRow][newCol] == -1)) {
                        liveNeighbors++;
                    }
                }

                // 2：当前为死亡，且周围活细胞为3，要更新为活
                if (board[i][j] == 0 && liveNeighbors == 3) {
                    board[i][j] = 2;
                }

                // -1：当前为活，且周围活细胞小于2或大于3，要更新为死
                if (board[i][j] == 1 && (liveNeighbors < 2 || liveNeighbors > 3)) {
                    board[i][j] = -1;
                }
            }
        }

        // 循环将状态更新
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 2) {
                    board[i][j] = 1;
                }
                if (board[i][j] == -1) {
                    board[i][j] = 0;
                }
            }
        }
        // O(m * n)
    }

    public static void main(String[] args) {
        int[][] board1 = {{0,1,0},{0,0,1},{1,1,1},{0,0,0}};
        int[][] board2 = {{1,1},{1,0}};

        GameOfLife289 gameOfLife = new GameOfLife289();
        gameOfLife.gameOfLife(board1);
        gameOfLife.gameOfLife(board2);

        System.out.println("Result 1:");
        for (int[] row : board1) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }

        System.out.println("Result 2:");
        for (int[] row : board2) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
    }
}

3.5 哈希表 Hash Table

  1. 快速查询和搜索
  2. 统计元素出现次数：重复元素、词频统计
  3. 映射关联：构建词典、映射关系等

383. 赎金信 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/*给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

        如果可以，返回 true ；否则返回 false 。

        magazine 中的每个字符只能在 ransomNote 中使用一次。



        示例 1：

        输入：ransomNote = "a", magazine = "b"
        输出：false
        示例 2：

        输入：ransomNote = "aa", magazine = "ab"
        输出：false
        示例 3：

        输入：ransomNote = "aa", magazine = "aab"
        输出：true


        提示：

        1 <= ransomNote.length, magazine.length <= 105
        ransomNote 和 magazine 由小写英文字母组成*/
public class RansomNote383 {
    public boolean canConstruct(String ransomNote, String magazine) {
/*        Map<Character, Integer> charCountMap = new HashMap<>();
        int i = 0;
        while (i < ransomNote.length()) {
            Character ch = ransomNote.charAt(i);
            charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
            i++;
        }
        int j = 0;
        while (j < magazine.length()) {
            Character ch = magazine.charAt(j);
            if (charCountMap.containsKey(ch)) {
                int count = charCountMap.get(ch);
                if (count <= 1) {
                    charCountMap.remove(ch);
                } else {
                    charCountMap.put(ch, count-1);
                }
            }
            j++;
        }
        //  O(n + m)
        return charCountMap.size() == 0;*/

        // 数组代替哈希表可以提高速度
        int[] charCount = new int[26];

        for (char ch : magazine.toCharArray()) {
            charCount[ch - 'a']++;
        }

        for (char ch : ransomNote.toCharArray()) {
            if (charCount[ch - 'a'] == 0) {
                return false;
            }
            charCount[ch - 'a']--;
        }

        //  O(n + m)
        return true;
    }

    public static void main(String[] args) {
        RansomNote383 note = new RansomNote383();

        System.out.println(note.canConstruct("a", "b"));
        System.out.println(note.canConstruct("aa", "ab"));
        System.out.println(note.canConstruct("aa", "aab"));
    }
}

205. 同构字符串 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/*给定两个字符串 s 和 t ，判断它们是否是同构的。

        如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

        每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

        示例 1:

        输入：s = "egg", t = "add"
        输出：true
        示例 2：

        输入：s = "foo", t = "bar"
        输出：false
        示例 3：

        输入：s = "paper", t = "title"
        输出：true


        提示：

        1 <= s.length <= 5 * 104
        t.length == s.length
        s 和 t 由任意有效的 ASCII 字符组成*/
public class IsomorphicStrings205 {
    public boolean isIsomorphic(String s, String t) {
        //if (s.length() != t.length()) {
        //    return false;
        //}
        //Map<Character, Character> sMap = new HashMap<>();
        //Map<Character, Character> tMap = new HashMap<>();
        //int i = 0;
        //while (i < s.length()) {
        //    Character sc = s.charAt(i);
        //    Character tc = t.charAt(i);
        //    if ((sMap.containsKey(sc) || tMap.containsKey(tc)) && (sMap.get(sc) != tc || tMap.get(tc) != sc)) {
        //        return false;
        //    } else {
        //        sMap.put(sc, tc);
        //        tMap.put(tc, sc);
        //    }
        //    i++;
        //}
        ////  O(n)
        //return true;


        if (s.length() != t.length()) {
            return false;
        }

        int[] sToT = new int[128];
        int[] tToS = new int[128];

        for (int i = 0; i < s.length(); i++) {
            char charS = s.charAt(i);
            char charT = t.charAt(i);

            if (sToT[charS] != tToS[charT]) {
                return false;
            }

            sToT[charS] = i + 1;
            tToS[charT] = i + 1;
        }

        return true;
    }

    public static void main(String[] args) {
        IsomorphicStrings205 test = new IsomorphicStrings205();

        System.out.println(test.isIsomorphic("egg", "add"));
        System.out.println(test.isIsomorphic("foo", "bar"));
        System.out.println(test.isIsomorphic("paper", "title"));
        System.out.println(test.isIsomorphic("badc", "baba"));
    }
}

290. 单词规律 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/*给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

        这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。



        示例1:

        输入: pattern = "abba", s = "dog cat cat dog"
        输出: true
        示例 2:

        输入:pattern = "abba", s = "dog cat cat fish"
        输出: false
        示例 3:

        输入: pattern = "aaaa", s = "dog cat cat dog"
        输出: false


        提示:

        1 <= pattern.length <= 300
        pattern 只包含小写英文字母
        1 <= s.length <= 3000
        s 只包含小写英文字母和 ' '
        s 不包含 任何前导或尾随对空格
        s 中每个单词都被 单个空格 分隔*/
public class WordPattern290 {
    public boolean wordPattern(String pattern, String s) {
        //Map<Character, String> pMap = new HashMap<>();
        //Map<String, Character> sMap = new HashMap<>();
        //String[] strings = s.split(" ");
        //
        //if (pattern.length() != strings.length) {
        //    return false;
        //}
        //int i = 0;
        //while (i < pattern.length()) {
        //    Character pc = pattern.charAt(i);
        //    String sc = strings[i];
        //    if ((sMap.containsKey(sc) || pMap.containsKey(pc)) && (sMap.get(sc) != pc || !pMap.get(pc).equals(sc))) {
        //        return false;
        //    } else {
        //        sMap.put(sc, pc);
        //        pMap.put(pc, sc);
        //    }
        //    i++;
        //}
        ////  O(n)
        //return true;
        Map<Character, String> pMap = new HashMap<>();
        String[] strings = s.split(" ");

        if (pattern.length() != strings.length) {
            return false;
        }

        for (int i = 0; i < pattern.length(); i++) {
            char pc = pattern.charAt(i);
            String sc = strings[i];

            if (pMap.containsKey(pc)) {
                if (!pMap.get(pc).equals(sc)) {
                    return false;
                }
            } else {
                if (pMap.containsValue(sc)) {
                    return false;
                }
                pMap.put(pc, sc);
            }
        }
        //  O(n)
        return true;
    }

    public static void main(String[] args) {
        WordPattern290 test = new WordPattern290();

        System.out.println(test.wordPattern("abba", "dog cat cat dog"));
        System.out.println(test.wordPattern("abba", "dog cat cat fish"));
        System.out.println(test.wordPattern("aaaa", "dog cat cat dog"));
    }
}

49. 字母异位词分组 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/*给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

        注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

        示例 1:

        输入: s = "anagram", t = "nagaram"
        输出: true
        示例 2:

        输入: s = "rat", t = "car"
        输出: false


        提示:

        1 <= s.length, t.length <= 5 * 104
        s 和 t 仅包含小写字母


        进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？*/
public class ValidAnagram242 {
    public boolean isAnagram(String s, String t) {
        //if (s.length() != t.length()) {
        //    return false;
        //}
        //
        //int[] sList = new int[26];
        //int[] tList = new int[26];
        //
        //for (int i = 0; i < s.length(); i++) {
        //    char charS = s.charAt(i);
        //    char charT = t.charAt(i);
        //    sList[charS- 'a']++;
        //    tList[charT- 'a']++;
        //}
        //for (int i = 0; i < sList.length; i++) {
        //    if (sList[i] != tList[i]) {
        //        return false;
        //    }
        //}
        //
        //// O(n)
        //return true;
        if (s.length() != t.length()) {
            return false;
        }

        int[] count = new int[26];

        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;
            count[t.charAt(i) - 'a']--;
        }

        for (int value : count) {
            if (value != 0) {
                return false;
            }
        }

        // O(n)
        return true;
    }

    public static void main(String[] args) {
        ValidAnagram242 test = new ValidAnagram242();
        System.out.println(test.isAnagram("anagram", "nagaram"));
        System.out.println(test.isAnagram("abba", "car"));
        System.out.println(test.isAnagram("nl", "cx"));
    }
}

49. 字母异位词分组 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/*给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

        字母异位词 是由重新排列源单词的所有字母得到的一个新单词。



        示例 1:

        输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
        输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
        示例 2:

        输入: strs = [""]
        输出: [[""]]
        示例 3:

        输入: strs = ["a"]
        输出: [["a"]]


        提示：

        1 <= strs.length <= 104
        0 <= strs[i].length <= 100
        strs[i] 仅包含小写字母*/
public class GroupAnagrams49 {
    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) {
            return new ArrayList<>();
        }

        Map<String, List<String>> map = new HashMap<>();
        for (String word : strs) {
            // 将字母排序，时间复杂度：O(m*logm) m为字符串最大长度
            char[] chars = word.toCharArray();
            Arrays.sort(chars);
            String sorted = String.valueOf(chars);

            // 映射表记录，相同sorted的word
            if (!map.containsKey(sorted)) {
                map.put(sorted, new ArrayList<>());
            }
            map.get(sorted).add(word);
        }

        // O(n * m * logm)
        return new ArrayList<>(map.values());
    }

    public static void main(String[] args) {
        GroupAnagrams49 test = new GroupAnagrams49(); // Assuming the class name is Solution

        // Example test cases
        String[] strs1 = {"eat", "tea", "tan", "ate", "nat", "bat"};
        List<List<String>> result1 = test.groupAnagrams(strs1);
        System.out.println("Anagram Groups for strs1: " + result1);

        String[] strs2 = {""};
        List<List<String>> result2 = test.groupAnagrams(strs2);
        System.out.println("Anagram Groups for strs2: " + result2);

        String[] strs3 = {"a"};
        List<List<String>> result3 = test.groupAnagrams(strs3);
        System.out.println("Anagram Groups for strs3: " + result3);
    }
}

1. 两数之和 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/*给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

        你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

        你可以按任意顺序返回答案。



        示例 1：

        输入：nums = [2,7,11,15], target = 9
        输出：[0,1]
        解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
        示例 2：

        输入：nums = [3,2,4], target = 6
        输出：[1,2]
        示例 3：

        输入：nums = [3,3], target = 6
        输出：[0,1]


        提示：

        2 <= nums.length <= 10^4
        -10^9 <= nums[i] <= 10^9
        -10^9 <= target <= 10^9
        只会存在一个有效答案


        进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？*/
public class TwoSum1 {
    public int[] twoSum(int[] nums, int target) {
        //int[] result = new int[2];
        //int i = 0, j = 1;
        //while (i < nums.length){
        //    if (nums[i] + nums[j] == target) {
        //        result[0] = i;
        //        result[1] = j;
        //        return result;
        //    } else if (j == nums.length - 1) {
        //        i++;
        //        j = i + 1;
        //    } else {
        //        j++;
        //    }
        //}
        ////  O(n^2)
        //return result;

        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            // 已遍历的元素存入map
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        // O(n)
        return new int[2];
    }

    public static void main(String[] args) {
        TwoSum1 test = new TwoSum1();
        int[] nums1 = {2,7,11,15};
        int target = 9;
        int[] result1 = test.twoSum(nums1, target);
        System.out.println("输出： " + Arrays.toString(result1)); // [0,1]

        int[] nums2 = {3,2,4};
        target = 6;
        int[] result2 = test.twoSum(nums2, target);
        System.out.println("输出： " + Arrays.toString(result2)); // [1,2]

        int[] nums3 = {3,3};
        target = 6;
        int[] result3 = test.twoSum(nums3, target);
        System.out.println("输出： " + Arrays.toString(result3)); // [0,1]

        int[] nums4 = {-1,-2,-3,-4,-5};
        target = -8;
        int[] result4 = test.twoSum(nums4, target);
        System.out.println("输出： " + Arrays.toString(result4)); // [2,4]
    }
}

202. 快乐数 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*编写一个算法来判断一个数 n 是不是快乐数。

        「快乐数」 定义为：

        对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
        然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
        如果这个过程 结果为 1，那么这个数就是快乐数。
        如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

        示例 1：

        输入：n = 19
        输出：true

        解释：
        1^2 + 9^2 = 82
        8^2 + 2^2 = 68
        6^2 + 8^2 = 100
        1^2 + 0^2 + 0^2 = 1

        示例 2：

        输入：n = 2
        输出：false

        提示：

        1 <= n <= 2^31 - 1*/
public class HappyNumber202 {
    public boolean isHappy(int n) {
        // 快慢指针
        int slow = n;
        int fast = getNext(n);

        // 当结果为1或者无限循环时退出
        while (fast != 1 && slow != fast) {
            slow = getNext(slow);
            fast = getNext(getNext(fast));
        }

        // O(logn)
        return fast == 1;
    }

    private int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            // 求n的各位置数字的平方和
            int digit = n % 10;
            n /= 10;
            totalSum += digit * digit;
        }
        return totalSum;
    }
    public static void main(String[] args) {
        HappyNumber202 test = new HappyNumber202();
        System.out.println(test.isHappy(19)); // true
        System.out.println(test.isHappy(2)); // false
    }
}

219. 存在重复元素 II <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

        示例 1：

        输入：nums = [1,2,3,1], k = 3
        输出：true

        示例 2：

        输入：nums = [1,0,1,1], k = 1
        输出：true

        示例 3：

        输入：nums = [1,2,3,1,2,3], k = 2
        输出：false

        提示：

        1 <= nums.length <= 105
        -109 <= nums[i] <= 109
        0 <= k <= 105*/
public class ContainsDuplicateII219 {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0;i < nums.length;i++) {
            if (map.containsKey(nums[i]) && Math.abs(map.get(nums[i]) - i) <= k) {
                return true;
            }
            map.put(nums[i], i);
        }
        return false;
    }
}

128. 最长连续序列 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

        请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

        示例 1：

        输入：nums = [100,4,200,1,3,2]
        输出：4
        解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

        示例 2：

        输入：nums = [0,3,7,2,5,8,4,6,0,1]
        输出：9

        提示：

        0 <= nums.length <= 105
        -109 <= nums[i] <= 109*/
public class LongestConsecutiveSequence128 {
    public int longestConsecutive(int[] nums) {
        // 将数组放入哈希集合
        Set<Integer> set = new HashSet<>();
        for (int num : nums) {
            set.add(num);
        }

        int maxSequence = 0;
        // 遍历数组
        for (int num : nums) {
            // 如果当前元素-1后不在哈希集合中，则它可能是一个起点
            if (!set.contains(num - 1)) {
                int currentNum = num;
                int currentSequence = 1;

                // 遍历获取连续序列
                while (set.contains(currentNum + 1)) {
                    currentNum++;
                    currentSequence++;
                }

                maxSequence = Math.max(maxSequence, currentSequence);
            }
        }

        // O(n)
        return maxSequence;
    }
}

3.6 区间 Interval

228. 汇总区间 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
/*给定一个  无重复元素 的 有序 整数数组 nums 。

        返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。

        列表中的每个区间范围 [a,b] 应该按如下格式输出：

        "a->b" ，如果 a != b
        "a" ，如果 a == b


        示例 1：

        输入：nums = [0,1,2,4,5,7]
        输出：["0->2","4->5","7"]
        解释：区间范围是：
        [0,2] --> "0->2"
        [4,5] --> "4->5"
        [7,7] --> "7"
        示例 2：

        输入：nums = [0,2,3,4,6,8,9]
        输出：["0","2->4","6","8->9"]
        解释：区间范围是：
        [0,0] --> "0"
        [2,4] --> "2->4"
        [6,6] --> "6"
        [8,9] --> "8->9"


        提示：

        0 <= nums.length <= 20
        -231 <= nums[i] <= 231 - 1
        nums 中的所有值都 互不相同
        nums 按升序排列*/
public class SummaryRanges228 {
    public List<String> summaryRanges(int[] nums) {
        //List<String> results = new ArrayList<>();
        //if (nums.length == 0) {
        //    return results;
        //}
        //int j, start = 0;
        //boolean flag = false;
        //for (int i = 0;i < nums.length;i++) {
        //    j = i + 1;
        //    if (j < nums.length && nums[j] > nums[i] + 1) {
        //        if (flag) {
        //            results.add(start + "->" + nums[i]);
        //            flag = false;
        //        } else {
        //            results.add(nums[i] + "");
        //        }
        //    } else if (j < nums.length && nums[j] == nums[i] + 1) {
        //        if (!flag) {
        //            start = nums[i];
        //            flag = true;
        //        }
        //    } else {
        //        if (flag) {
        //            results.add(start + "->" + nums[i]);
        //            flag = false;
        //        } else {
        //            results.add(nums[i] + "");
        //        }
        //    }
        //}
        //return results;
        List<String> result = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return result;
        }

        for (int i = 0; i < nums.length; i++) {
            int start = nums[i];
            // 有连续数字时，循环跳过
            while (i + 1 < nums.length && nums[i + 1] == nums[i] + 1) {
                i++;
            }
            int end = nums[i];
            if (start == end) {
                result.add(Integer.toString(start));
            } else {
                result.add(start + "->" + end);
            }
        }

        return result;
    }

    public static void main(String[] args) {
        SummaryRanges228 test = new SummaryRanges228();
        //int[] nums1 = {0,1,2,4,5,7};
        //System.out.println(test.summaryRanges(nums1)); // ["0->2","4->5","7"]
        int[] nums2 = {0,2,3,4,6,8,9};
        System.out.println(test.summaryRanges(nums2)); // ["0","2->4","6","8->9"]
    }
}

56. 合并区间 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

        示例 1：

        输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
        输出：[[1,6],[8,10],[15,18]]
        解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
        示例 2：

        输入：intervals = [[1,4],[4,5]]
        输出：[[1,5]]
        解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。


        提示：

        1 <= intervals.length <= 104
        intervals[i].length == 2
        0 <= starti <= endi <= 104*/
public class MergeIntervals56 {
    public int[][] merge(int[][] intervals) {
        //Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
        //List<int[]> results = new ArrayList<>();
        //for (int[] interval : intervals) {
        //    if (results.isEmpty() || results.get(results.size() - 1)[1] < interval[0]) {
        //        // 若数组为空，或当前区间不覆盖数组已有区间，直接加入数组
        //        results.add(interval);
        //    } else {
        //        // 否则当前区间覆盖数组最后一个区间，通过更新结束边界来更新区间
        //        results.get(results.size() - 1)[1] = Math.max(results.get(results.size() - 1)[1], interval[1]);
        //    }
        //}
        //// O(n log n)
        //return results.toArray(new int[results.size()][]);

        List<int[]> result = new ArrayList<>();
        if (intervals.length == 0) {
            return result.toArray(new int[0][]);
        }
        // 先保证有序
        Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
        int[] currentInterval = intervals[0];
        result.add(currentInterval);

        for (int[] interval : intervals) {
            int currentEnd = currentInterval[1];
            int nextStart = interval[0];
            int nextEnd = interval[1];

            if (currentEnd >= nextStart) {
                currentInterval[1] = Math.max(currentEnd, nextEnd);
            } else {
                currentInterval = interval;
                result.add(currentInterval);
            }
        }

        return result.toArray(new int[result.size()][]);
    }
    public static void main(String[] args) {
        MergeIntervals56 test = new MergeIntervals56();
        int[][] intervals1 = {{1,3},{2,6},{8,10},{15,18}};
        printArray(test.merge(intervals1)); // [[1,6],[8,10],[15,18]]
        int[][] intervals2 = {{1,4},{4,5}};
        printArray(test.merge(intervals2)); // [[1,5]]
        int[][] intervals3 = {{1,4},{0,4}};
        printArray(test.merge(intervals3)); // [[0,4]]
        int[][] intervals4 = {{1,4},{2,3}};
        printArray(test.merge(intervals4)); // [[1,4]]
    }
    public static void printArray(int[][] matrix) {
        for (int[] row : matrix) {
            System.out.print("[");
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.print("]");
        }
        System.out.println();
    }
}

57. 插入区间 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
/*给你一个 无重叠的 ，按照区间起始端点排序的区间列表。

        在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。

        示例 1：

        输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
        输出：[[1,5],[6,9]]
        示例 2：

        输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
        输出：[[1,2],[3,10],[12,16]]
        解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
        示例 3：

        输入：intervals = [], newInterval = [5,7]
        输出：[[5,7]]
        示例 4：

        输入：intervals = [[1,5]], newInterval = [2,3]
        输出：[[1,5]]
        示例 5：

        输入：intervals = [[1,5]], newInterval = [2,7]
        输出：[[1,7]]


        提示：

        0 <= intervals.length <= 104
        intervals[i].length == 2
        0 <= intervals[i][0] <= intervals[i][1] <= 105
        intervals 根据 intervals[i][0] 按 升序 排列
        newInterval.length == 2
        0 <= newInterval[0] <= newInterval[1] <= 105*/
public class InsertInterval57 {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        List<int[]> result = new ArrayList<>();

        int i = 0;
        int n = intervals.length;

        // 先将原区间集合在新区间之前的插入数组
        while (i < n && intervals[i][1] < newInterval[0]) {
            result.add(intervals[i]);
            i++;
        }

        // 若新区间在当前区间开始之后
        while (i < n && intervals[i][0] <= newInterval[1]) {
            // 将新区间置换，取更小的左边和最大的右边
            newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
            newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
            i++;
        }
        result.add(newInterval);

        // 将剩余区间加入数组
        while (i < n) {
            result.add(intervals[i]);
            i++;
        }

        // O(n)
        return result.toArray(new int[result.size()][]);
    }

    public static void main(String[] args) {
        InsertInterval57 inserter = new InsertInterval57();

        int[][] intervals1 = {{1, 3}, {6, 9}};
        int[] newInterval1 = {2, 5};
        print(inserter.insert(intervals1, newInterval1));//[[1,5],[6,9]]

        int[][] intervals2 = {{1,2},{3,5},{6,7},{8,10},{12,16}};
        int[] newInterval2 = {4,8};
        print(inserter.insert(intervals2, newInterval2));//[[1,2],[3,10],[12,16]]

        int[][] intervals3 = {{1,5}};
        int[] newInterval3 = {2,3};
        print(inserter.insert(intervals3, newInterval3));//[[1,5]]

        int[][] intervals4 = {{1,5}};
        int[] newInterval4 = {2,7};
        print(inserter.insert(intervals4, newInterval4));//[[1,7]]
    }

    public static void print(int[][] mergedIntervals) {
        for (int[] interval : mergedIntervals) {
            System.out.print(Arrays.toString(interval));
        }
        System.out.println();
    }

}

452. 用最少数量的箭引爆气球 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

        一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。

        给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。


        示例 1：

        输入：points = [[10,16],[2,8],[1,6],[7,12]]
        输出：2
        解释：气球可以用2支箭来爆破:
        -在x = 6处射出箭，击破气球[2,8]和[1,6]。
        -在x = 11处发射箭，击破气球[10,16]和[7,12]。
        示例 2：

        输入：points = [[1,2],[3,4],[5,6],[7,8]]
        输出：4
        解释：每个气球需要射出一支箭，总共需要4支箭。
        示例 3：

        输入：points = [[1,2],[2,3],[3,4],[4,5]]
        输出：2
        解释：气球可以用2支箭来爆破:
        - 在x = 2处发射箭，击破气球[1,2]和[2,3]。
        - 在x = 4处射出箭，击破气球[3,4]和[4,5]。


        提示:

        1 <= points.length <= 105
        points[i].length == 2
        -231 <= xstart < xend <= 231 - 1*/
public class MinimumNumberOfArrowsToBurstBalloons452 {
    public int findMinArrowShots(int[][] points) {
        // 排序 + 贪心
        if (points == null || points.length == 0) {
            return 0;
        }

        // 通过右边界排序
        Arrays.sort(points, Comparator.comparingInt(a -> a[1]));

        int arrows = 1;
        int end = points[0][1];

        // 遍历气球节点
        for (int i = 1; i < points.length; i++) {
            // 若当前节点与end不重叠，箭数增加，更新新的end
            if (points[i][0] > end) {
                arrows++;
                end = points[i][1];
            }
        }

        // O(n log n)
        return arrows;
    }
    public static void main(String[] args) {
        MinimumNumberOfArrowsToBurstBalloons452 minArrows = new MinimumNumberOfArrowsToBurstBalloons452();
        int[][] points1 = {{10, 16}, {2, 8}, {1, 6}, {7, 12}};
        int[][] points2 = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
        int[][] points3 = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};

        System.out.println(minArrows.findMinArrowShots(points1)); // Output: 2
        System.out.println(minArrows.findMinArrowShots(points2)); // Output: 4
        System.out.println(minArrows.findMinArrowShots(points3)); // Output: 2
    }
}

3.7 栈 Stack

20. 有效的括号 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/*给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

        有效字符串需满足：

        左括号必须用相同类型的右括号闭合。
        左括号必须以正确的顺序闭合。
        每个右括号都有一个对应的相同类型的左括号。


        示例 1：

        输入：s = "()"
        输出：true
        示例 2：

        输入：s = "()[]{}"
        输出：true
        示例 3：

        输入：s = "(]"
        输出：false


        提示：

        1 <= s.length <= 104
        s 仅由括号 '()[]{}' 组成*/
public class ValidParentheses20 {
    public boolean isValid(String s) {
        if (s.length() < 2 || s.length() % 2 == 1) {
            return false;
        }
        Stack<Character> stack = new Stack<>();
        int i = 0;
        // 遍历遇到左括号入栈，遇到右括号出栈，判断是否匹配
        while (i < s.length()) {
            char ch = s.charAt(i);
            if (left(ch)) {
                // 左括号
                stack.push(s.charAt(i));
            } else if (!stack.empty()) {
                // 右括号，并且栈中有左括号
                char left = stack.pop();
                if (!match(left, ch)) {
                    return false;
                }
            } else {
                // 右括号，栈中没有左括号
                return false;
            }
            i++;
        }

        // O(n)
        // 栈中括号是否全部匹配
        return stack.empty();
    }

    public boolean match(char left, char right) {
        if (left == '(') {
            return right == ')';
        } else if (left == '{') {
            return right == '}';
        } else if (left == '[') {
            return right == ']';
        } else {
            return false;
        }
    }

    public boolean left(char left) {
        return left == '(' || left == '{' || left == '[';
    }

    public static void main(String[] args) {
        ValidParentheses20 test = new ValidParentheses20();

        System.out.println(test.isValid("()")); // true
        System.out.println(test.isValid("()[]{}")); // true
        System.out.println(test.isValid("(]")); // false
    }
}

71. 简化路径 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/*给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为更加简洁的规范路径。

        在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，'//'）都被视为单个斜杠 '/' 。 对于此问题，任何其他格式的点（例如，'...'）均被视为文件/目录名称。

        请注意，返回的 规范路径 必须遵循下述格式：

        始终以斜杠 '/' 开头。
        两个目录名之间必须只有一个斜杠 '/' 。
        最后一个目录名（如果存在）不能 以 '/' 结尾。
        此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。
        返回简化后得到的 规范路径 。



        示例 1：

        输入：path = "/home/"
        输出："/home"
        解释：注意，最后一个目录名后面没有斜杠。
        示例 2：

        输入：path = "/../"
        输出："/"
        解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。
        示例 3：

        输入：path = "/home//foo/"
        输出："/home/foo"
        解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
        示例 4：

        输入：path = "/a/./b/../../c/"
        输出："/c"


        提示：

        1 <= path.length <= 3000
        path 由英文字母，数字，'.'，'/' 或 '_' 组成。
        path 是一个有效的 Unix 风格绝对路径。*/
public class SimplifyPath71 {
    public static String simplifyPath(String path) {
        Deque<String> stack = new ArrayDeque<>();
        Set<String> skip = new HashSet<>(Arrays.asList(".", ""));

        // 根据/分割字符串
        for (String dir : path.split("/")) {
            if (dir.equals("..")) {
                // ..表示返回上一级，弹出栈顶元素
                if (!stack.isEmpty()) {
                    stack.pop();
                }
            } else if (!skip.contains(dir)) {
                // 有效目录，则存放入栈
                stack.push(dir);
            }
            // 其余直接跳过
        }

        // 栈中剩余的元素即为简化后的路径
        StringBuilder result = new StringBuilder();
        while (!stack.isEmpty()) {
            result.insert(0, "/" + stack.pop());
        }
        // O(n)
        return result.length() == 0 ? "/" : result.toString();
    }

    public static void main(String[] args) {
        String[] testCases = {"/home/", "/../", "/home//foo/", "/a/./b/../../c/", "/a/./b/../../...c/"};
        for (String path : testCases) {
            System.out.println("Input: " + path);
            System.out.println("Output: " + simplifyPath(path));
        }
    }
}

155. 最小栈 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/*设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

        实现 MinStack 类:

        MinStack() 初始化堆栈对象。
        void push(int val) 将元素val推入堆栈。
        void pop() 删除堆栈顶部的元素。
        int top() 获取堆栈顶部的元素。
        int getMin() 获取堆栈中的最小元素。


        示例 1:

        输入：
        ["MinStack","push","push","push","getMin","pop","top","getMin"]
        [[],[-2],[0],[-3],[],[],[],[]]

        输出：
        [null,null,null,null,-3,null,0,-2]

        解释：
        MinStack minStack = new MinStack();
        minStack.push(-2);
        minStack.push(0);
        minStack.push(-3);
        minStack.getMin();   --> 返回 -3.
        minStack.pop();
        minStack.top();      --> 返回 0.
        minStack.getMin();   --> 返回 -2.


        提示：

        -231 <= val <= 231 - 1
        pop、top 和 getMin 操作总是在 非空栈 上调用
        push, pop, top, and getMin最多被调用 3 * 104 次*/
public class MinStack155 {

    // 存储元素
    Stack<Integer> stack;
    // 存储当前栈中的最小元素
    Stack<Integer> minStack;

    public MinStack155() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }

    public void push(int val) {
        stack.push(val);
        // 新值为当前最小元素，则入栈
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }

    public void pop() {
        // 如果栈顶是最小元素，则两个栈都要出栈
        if (stack.peek().equals(minStack.peek())) {
            minStack.pop();
        }
        stack.pop();
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return minStack.peek();
    }

    public static void main(String[] args) {
        MinStack155 minStack = new MinStack155();
        minStack.push(-2);
        minStack.push(0);
        minStack.push(-3);
        System.out.println(minStack.getMin());   // Output: -3
        minStack.pop();
        System.out.println(minStack.top());      // Output: 0
        System.out.println(minStack.getMin());   // Output: -2
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

150. 逆波兰表达式求值 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/*给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

        请你计算该表达式。返回一个表示表达式值的整数。

        注意：

        有效的算符为 '+'、'-'、'*' 和 '/' 。
        每个操作数（运算对象）都可以是一个整数或者另一个表达式。
        两个整数之间的除法总是 向零截断 。
        表达式中不含除零运算。
        输入是一个根据逆波兰表示法表示的算术表达式。
        答案及所有中间计算结果可以用 32 位 整数表示。


        示例 1：

        输入：tokens = ["2","1","+","3","*"]
        输出：9
        解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
        示例 2：

        输入：tokens = ["4","13","5","/","+"]
        输出：6
        解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
        示例 3：

        输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
        输出：22
        解释：该算式转化为常见的中缀算术表达式为：
        ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
        = ((10 * (6 / (12 * -11))) + 17) + 5
        = ((10 * (6 / -132)) + 17) + 5
        = ((10 * 0) + 17) + 5
        = (0 + 17) + 5
        = 17 + 5
        = 22


        提示：

        1 <= tokens.length <= 104
        tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数


        逆波兰表达式：

        逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

        平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
        该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
        逆波兰表达式主要有以下两个优点：

        去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
        适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中*/
public class EvaluateReversePolishNotation150 {
    public int evalRPN(String[] tokens) {
        Deque<String> stack = new ArrayDeque<>();
        int result = 0;
        for (String token : tokens) {
            if (isDigit(token)) {
                // 数字
                stack.push(token);
            } else {
                // 运算符号
                int b = Integer.parseInt(stack.pop());
                int a = Integer.parseInt(stack.pop());
                if ("+".equals(token)) {
                    result = a + b;
                } else if ("-".equals(token)) {
                    result = a - b;
                } else if ("*".equals(token)) {
                    result = a * b;
                } else if ("/".equals(token)) {
                    result = a / b;
                }
                stack.push(result + "");
            }
        }
        if (stack.isEmpty()) {
            return 0;
        } else {
            return Integer.parseInt(stack.pop());
        }
    }

    public boolean isDigit(String token) {
        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
    }

    public static void main(String[] args) {
        EvaluateReversePolishNotation150 test = new EvaluateReversePolishNotation150();
        String[] tokens1 = {"2","1","+","3","*"};
        System.out.println(test.evalRPN(tokens1)); // 9
        String[] tokens2 = {"4","13","5","/","+"};
        System.out.println(test.evalRPN(tokens2)); // 6
        String[] tokens3 = {"10","6","9","3","+","-11","*","/","*","17","+","5","+"};
        System.out.println(test.evalRPN(tokens3)); // 22
    }
}

224. 基本计算器 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/*给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

        注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。



        示例 1：

        输入：s = "1 + 1"
        输出：2
        示例 2：

        输入：s = " 2-1 + 2 "
        输出：3
        示例 3：

        输入：s = "(1+(4+5+2)-3)+(6+8)"
        输出：23


        提示：

        1 <= s.length <= 3 * 105
        s 由数字、'+'、'-'、'('、')'、和 ' ' 组成
        s 表示一个有效的表达式
        '+' 不能用作一元运算(例如， "+1" 和 "+(2 + 3)" 无效)
        '-' 可以用作一元运算(即 "-1" 和 "-(2 + 3)" 是有效的)
        输入中不存在两个连续的操作符
        每个数字和运行的计算将适合于一个有符号的 32位 整数*/
public class BasicCalculator224 {
    public static int calculate(String s) {
        //维护两个栈，一个用于存储数字，一个用于存储运算符号
        Deque<Integer> numStack = new ArrayDeque<>();
        Deque<Integer> signStack = new ArrayDeque<>();
        // 当前数字的值
        int num = 0;
        // 当前数字的符号
        int sign = 1;
        // 当前的计算结果
        int result = 0;

        for (char ch : s.toCharArray()) {
            if (Character.isDigit(ch)) {
                // 数字，若之前已有字符为数字，则需要进位
                num = num * 10 + (ch - '0');
            } else if (ch == '+' || ch == '-') {
                // +或-，更新结果 result，然后重置 num 和 sign
                result += sign * num;
                num = 0;
                // 减号作为下一数字的负符号
                sign = (ch == '+') ? 1 : -1;
            } else if (ch == '(') {
                // 将当前结果 result 和当前符号 sign 入栈，重置 result 和 sign
                numStack.push(result);
                signStack.push(sign);
                result = 0;
                sign = 1;
            } else if (ch == ')') {
                // 右括号，则弹出栈顶元素存放的之前的结果进行计算，并更新 result 和 sign
                // 当前括号结果
                result += sign * num;
                result *= signStack.pop();
                // 加上之前的结果
                result += numStack.pop();
                num = 0;
            }
        }

        result += sign * num;
        // O(n)
        return result;
    }

    public static void main(String[] args) {
        String expr1 = "1 + 1";
        String expr2 = " 2-1 + 2 ";
        String expr3 = "(1+(4+5+2)-3)+(6+8)";

        System.out.println("Expr 1 result: " + calculate(expr1)); // Output: 2
        System.out.println("Expr 2 result: " + calculate(expr2)); // Output: 3
        System.out.println("Expr 3 result: " + calculate(expr3)); // Output: 23
    }
}

3.8 链表 Linked List

141. 环形链表 <easy> 快慢指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/*给你一个链表的头节点 head ，判断链表中是否有环。

        如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

        如果链表中存在环 ，则返回 true 。 否则，返回 false 。



        示例 1：



        输入：head = [3,2,0,-4], pos = 1
        输出：true
        解释：链表中有一个环，其尾部连接到第二个节点。
        示例 2：



        输入：head = [1,2], pos = 0
        输出：true
        解释：链表中有一个环，其尾部连接到第一个节点。
        示例 3：



        输入：head = [1], pos = -1
        输出：false
        解释：链表中没有环。


        提示：

        链表中节点的数目范围是 [0, 104]
        -105 <= Node.val <= 105
        pos 为 -1 或者链表中的一个 有效索引 。


        进阶：你能用 O(1)（即，常量）内存解决此问题吗？*/

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class LinkedListCycle141 {
    public static boolean hasCycle(ListNode head) {
        // 使用快慢指针解决。通过两个指针在链表上移动来判断是否有环。
        if (head == null || head.next == null) {
            return false;
        }

        // 定义两个指针，一个慢指针 slow，一次移动一个节点；一个快指针 fast，一次移动两个节点。如果链表中有环，那么快指针终究会追上慢指针
        ListNode slow = head;
        ListNode fast = head.next;

        while (fast != null && fast.next != null) {
            // 每次移动后，判断 slow 和 fast 是否指向相同的节点
            if (slow == fast) {
                // 如果是，则链表中有环
                return true;
            }
            // 慢指针 slow 移动一步
            slow = slow.next;
            // 快指针 fast 移动两步
            fast = fast.next.next;
        }

        // O(N) O(1)
        return false;
    }

    public static void main(String[] args) {
        ListNode head1 = new ListNode(3);
        head1.next = new ListNode(2);
        head1.next.next = new ListNode(0);
        head1.next.next.next = new ListNode(-4);
        head1.next.next.next.next = head1.next; // Creating a cycle

        ListNode head2 = new ListNode(1);
        head2.next = new ListNode(2);
        head2.next.next = head2; // Creating a cycle

        ListNode head3 = new ListNode(1);

        System.out.println("Has cycle in head1: " + hasCycle(head1)); // Output: true
        System.out.println("Has cycle in head2: " + hasCycle(head2)); // Output: true
        System.out.println("Has cycle in head3: " + hasCycle(head3)); // Output: false
    }

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

2. 两数相加 <medium> 遍历同时逐位相加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/*给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

        请你将两个数相加，并以相同形式返回一个表示和的链表。

        你可以假设除了数字 0 之外，这两个数都不会以 0 开头。



        示例 1：


        输入：l1 = [2,4,3], l2 = [5,6,4]
        输出：[7,0,8]
        解释：342 + 465 = 807.
        示例 2：

        输入：l1 = [0], l2 = [0]
        输出：[0]
        示例 3：

        输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
        输出：[8,9,9,9,0,0,0,1]


        提示：

        每个链表中的节点数在范围 [1, 100] 内
        0 <= Node.val <= 9
        题目数据保证列表表示的数字不含前导零*/

import java.math.BigDecimal;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class AddTwoNumbers2 {

    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 普通解法：通过将链表转换为整数进行相加，然后再将结果转换回链表
        // 因为每个链表中的节点数在范围 [1, 100] 内，所以int和long的长度都不足
        //BigDecimal a = BigDecimal.ZERO;
        //BigDecimal x = BigDecimal.ONE;
        //while (l1 != null) {
        //    a = a.add(x.multiply(BigDecimal.valueOf(l1.val)));
        //    x = x.multiply(BigDecimal.TEN);
        //    l1 = l1.next;
        //}
        //
        //BigDecimal b = BigDecimal.ZERO;
        //x = BigDecimal.ONE;
        //while (l2 != null) {
        //    b = b.add(x.multiply(BigDecimal.valueOf(l2.val)));
        //    x = x.multiply(BigDecimal.TEN);
        //    l2 = l2.next;
        //}
        //BigDecimal c = a.add(b);
        //String string = c + "";
        //ListNode result = new ListNode(Character.getNumericValue(string.charAt(string.length() - 1)));
        //ListNode first = result;
        //for (int i = string.length() - 2;i >= 0;i--) {
        //    ListNode temp = new ListNode(Character.getNumericValue(string.charAt(i)));
        //    result.next = temp;
        //    result = temp;
        //}
        //
        //return first;

        // 优化：在遍历链表的同时，逐位相加并构建新链表作为结果。
        ListNode dummyHead = new ListNode();
        ListNode current = dummyHead;
        // 处理每个节点相加后的进位。当两个节点相加的和大于等于 10 时，需要将进位值传递到下一个节点的计算中。
        int carry = 0;

        // 同时遍历两个链表
        while (l1 != null || l2 != null) {
            int x = (l1 != null) ? l1.val : 0;
            int y = (l2 != null) ? l2.val : 0;

            // 计算当前位的和，并更新进位
            int sum = carry + x + y;
            carry = sum / 10;

            // 将加后的节点构建新的链表节点
            current.next = new ListNode(sum % 10);
            current = current.next;

            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }

        if (carry > 0) {
            current.next = new ListNode(carry);
        }

        return dummyHead.next;
    }

    public static void printLinkedList(ListNode head) {
        while (head != null) {
            System.out.print(head.val);
            head = head.next;
            if (head != null) {
                System.out.print(" -> ");
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        AddTwoNumbers2.ListNode l1 = new AddTwoNumbers2.ListNode(2);
        l1.next = new AddTwoNumbers2.ListNode(4);
        l1.next.next = new AddTwoNumbers2.ListNode(3);
        AddTwoNumbers2.ListNode l2 = new AddTwoNumbers2.ListNode(5);
        l2.next = new AddTwoNumbers2.ListNode(6);
        l2.next.next = new AddTwoNumbers2.ListNode(4);

        AddTwoNumbers2.ListNode l3 = new AddTwoNumbers2.ListNode(0);
        AddTwoNumbers2.ListNode l4 = new AddTwoNumbers2.ListNode(0);

        AddTwoNumbers2.ListNode l5 = new AddTwoNumbers2.ListNode(9);
        l5.next = new AddTwoNumbers2.ListNode(9);
        l5.next.next = new AddTwoNumbers2.ListNode(9);
        l5.next.next.next = new AddTwoNumbers2.ListNode(9);
        l5.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l5.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l5.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        AddTwoNumbers2.ListNode l6 = new AddTwoNumbers2.ListNode(9);
        l6.next = new AddTwoNumbers2.ListNode(9);
        l6.next.next = new AddTwoNumbers2.ListNode(9);
        l6.next.next.next = new AddTwoNumbers2.ListNode(9);

        // 数字长度10，int不够用
        AddTwoNumbers2.ListNode l7 = new AddTwoNumbers2.ListNode(9);
        AddTwoNumbers2.ListNode l8 = new AddTwoNumbers2.ListNode(1);
        l8.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);
        l8.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(9);

        // 数字长度超过19，long不够用
        AddTwoNumbers2.ListNode l9 = new AddTwoNumbers2.ListNode(1);
        l9.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next= new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(0);
        l9.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next = new AddTwoNumbers2.ListNode(1);

        AddTwoNumbers2.ListNode l10 = new AddTwoNumbers2.ListNode(5);
        l10.next = new AddTwoNumbers2.ListNode(6);
        l10.next.next = new AddTwoNumbers2.ListNode(4);

        printLinkedList(addTwoNumbers(l1, l2));// Output: [7,0,8]
        printLinkedList(addTwoNumbers(l3, l4)); // Output: [0]
        printLinkedList(addTwoNumbers(l5, l6)); // Output: [8,9,9,9,0,0,0,1]
        printLinkedList(addTwoNumbers(l7, l8)); // Output: [0,0,0,0,0,0,0,0,0,0,1]
        printLinkedList(addTwoNumbers(l9, l10)); // [6,6,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
}

21. 合并两个有序链表 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/*将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

        示例 1：


        输入：l1 = [1,2,4], l2 = [1,3,4]
        输出：[1,1,2,3,4,4]
        示例 2：

        输入：l1 = [], l2 = []
        输出：[]
        示例 3：

        输入：l1 = [], l2 = [0]
        输出：[0]


        提示：

        两个链表的节点数目范围是 [0, 50]
        -100 <= Node.val <= 100
        l1 和 l2 均按 非递减顺序 排列*/

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class MergeTwoSortedLists21 {
    public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        // 先构建一个假节点作为起点
        ListNode result = new ListNode(-1);
        // current指向当前节点
        ListNode current = result;

        while (list1 != null && list2 != null) {
            // 两个链表都不为空时
            if (list1.val <= list2.val) {
                // 指向小的节点
                current.next = list1;
                list1 = list1.next;
            } else {
                current.next = list2;
                list2 = list2.next;
            }
            current = current.next;
        }

        // 若还有链表不为空，则指向该链表
        current.next = (list1 != null) ? list1 : list2;

        // O(m + n)
        return result.next;
    }

    // Helper method to print the linked list
    public void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        MergeTwoSortedLists21 merger = new MergeTwoSortedLists21();

        // Example 1
        ListNode l1 = new ListNode(1, new ListNode(2, new ListNode(4)));
        ListNode l2 = new ListNode(1, new ListNode(3, new ListNode(4)));
        ListNode result1 = merger.mergeTwoLists(l1, l2);
        merger.printList(result1);

        // Example 2
        ListNode l3 = null;
        ListNode l4 = null;
        ListNode result2 = merger.mergeTwoLists(l3, l4);
        merger.printList(result2);

        // Example 3
        ListNode l5 = null;
        ListNode l6 = new ListNode(0);
        ListNode result3 = merger.mergeTwoLists(l5, l6);
        merger.printList(result3);
    }

    public static class ListNode {
        int val;
        MergeTwoSortedLists21.ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, MergeTwoSortedLists21.ListNode next) { this.val = val; this.next = next; }
    }
}

138. 随机链表的复制 <medium> Map提前生成复制节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

/*给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

        构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

        例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

        返回复制链表的头节点。

        用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

        val：一个表示 Node.val 的整数。
        random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为  null 。
        你的代码 只 接受原链表的头节点 head 作为传入参数。

        示例 1：

        输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
        输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
        示例 2：

        输入：head = [[1,1],[2,1]]
        输出：[[1,1],[2,1]]
        示例 3：

        输入：head = [[3,null],[3,0],[3,null]]
        输出：[[3,null],[3,0],[3,null]]

        提示：

        0 <= n <= 1000
        -104 <= Node.val <= 104
        Node.random 为 null 或指向链表中的节点。*/
public class CopyListWithRandomPointer138 {


    public Node copyRandomList(Node head) {
        if (head == null) return null;

        // 通过一个map来记录原链表节点和复制链表的映射关系
        Map<Node, Node> map = new HashMap<>();

        // 遍历链表，将复制节点存入map
        Node current = head;
        while (current != null) {
            map.put(current, new Node(current.val));
            current = current.next;
        }

        // 再次遍历链表，
        current = head;
        while (current != null) {
            // 连接复制节点的next和random，都从map中找到对应原节点的复制节点
            map.get(current).next = map.get(current.next);
            map.get(current).random = map.get(current.random);
            current = current.next;
        }

        return map.get(head);
    }

    public void printRandomList(Node head) {
        Node current = head;
        while (current != null) {
            System.out.print("[" + current.val + ", ");
            if (current.random != null) {
                System.out.print(current.random.val + "]");
            } else {
                System.out.print("null]");
            }
            if (current.next != null) {
                System.out.print(" -> ");
            }
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        CopyListWithRandomPointer138 copier = new CopyListWithRandomPointer138();

        // Example 1
        CopyListWithRandomPointer138.Node node1 = copier.new Node(7);
        CopyListWithRandomPointer138.Node node2 = copier.new Node(13);
        CopyListWithRandomPointer138.Node node3 = copier.new Node(11);
        CopyListWithRandomPointer138.Node node4 = copier.new Node(10);
        CopyListWithRandomPointer138.Node node5 = copier.new Node(1);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        node1.random = null;
        node2.random = node1;
        node3.random = node5;
        node4.random = node3;
        node5.random = node1;

        CopyListWithRandomPointer138.Node result1 = copier.copyRandomList(node1);
        copier.printRandomList(result1);

        // Example 2
        CopyListWithRandomPointer138.Node node6 = copier.new Node(1);
        CopyListWithRandomPointer138.Node node7 = copier.new Node(2);
        node6.next = node7;
        node6.random = node7;
        node7.random = node7;

        CopyListWithRandomPointer138.Node result2 = copier.copyRandomList(node6);
        copier.printRandomList(result2);

        // Example 3
        CopyListWithRandomPointer138.Node node8 = copier.new Node(3);
        CopyListWithRandomPointer138.Node node9 = copier.new Node(3);
        CopyListWithRandomPointer138.Node node10 = copier.new Node(3);
        node8.next = node9;
        node9.next = node10;
        node9.random = node8;

        CopyListWithRandomPointer138.Node result3 = copier.copyRandomList(node8);
        copier.printRandomList(result3);
    }
    
    public class Node {
        int val;
        Node next;
        Node random;

        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }
}

92. 反转链表 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
/*给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

        示例 1：

        输入：head = [1,2,3,4,5], left = 2, right = 4
        输出：[1,4,3,2,5]
        示例 2：

        输入：head = [5], left = 1, right = 1
        输出：[5]

        提示：

        链表中节点数目为 n
        1 <= n <= 500
        -500 <= Node.val <= 500
        1 <= left <= right <= n*/

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class ReverseLinkedListII92 {

    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (left == right) {
            return head;
        }

        Deque<ListNode> stack = new ArrayDeque<>();
        ListNode current = head;
        // left前一个节点
        ListNode last = head;
        // right后一个节点
        ListNode end = head;
        int i = 1;
        while (i <= right) {
            if (i < left) {
                // i指向left前最后一个节点
                last = current;
            } else if (i >= left && i < right) {
                // 将i在区域内的节点入栈
                stack.push(current);
            } else if (i == right) {
                // 到达右节点
                stack.push(current);
                end = current.next;
            }
            current = current.next;
            i++;
        }

        if (left == 1) {
            // 从head开始反转时，要更新head
            head = stack.pop();
            last = head;
        }

        while (!stack.isEmpty()) {
            last.next = stack.pop();
            last = last.next;
        }

        if (end != head) {
            last.next = end;
        }

        return head;
    }


    public void printList(ReverseLinkedListII92.ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ReverseLinkedListII92 test = new ReverseLinkedListII92();

        ListNode l1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        test.printList(test.reverseBetween(l1, 2, 4)); // [1,4,3,2,5]

        ListNode l2 = new ListNode(5);
        test.printList(test.reverseBetween(l2, 1, 1)); // [5]

        ListNode l3 = new ListNode(3, new ListNode(5));
        test.printList(test.reverseBetween(l3, 1, 2)); // [5,3]
    }

    public static class ListNode {
        int val;
        ReverseLinkedListII92.ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ReverseLinkedListII92.ListNode next) { this.val = val; this.next = next; }

        @Override
        public String toString() {
            return val + "";
        }
    }
    
    // 直接反转
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (head == null || left == right) return head; // 边界情况，直接返回
        int index = 1;
        ListNode last = null, start = null, end = null, prev = null, current = head;

        // 遍历链表，找到要反转的部分
        while (current != null && index <= right) {
            ListNode next = current.next;

            if (index < left) {
                last = current; // 记录left前一个节点
            } else if (index == left) {
                start = current; // 记录left开始的节点
                prev = null; // 开始反转
            }

            // 反转 [left, right] 范围内的节点
            if (index >= left && index <= right) {
                current.next = prev;
                prev = current;
            }

            if (index == right) {
                end = next; // 记录right后一个节点
                break;
            }

            current = next;
            index++;
        }

        // 连接反转后的链表部分
        if (last != null) {
            last.next = prev; // 连接反转后的头
        } else {
            head = prev; // 如果 `left == 1`，反转部分变成新的头
        }

        if (start != null) {
            start.next = end; // 连接反转部分的尾部到end
        }

        return head;
    }
}

143. 重排链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
/*给定一个单链表 L 的头节点 head ，单链表 L 表示为：

        L0 → L1 → … → Ln - 1 → Ln
        请将其重新排列后变为：

        L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
        不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

        示例 1：

        输入：head = [1,2,3,4]
        输出：[1,4,2,3]
        示例 2：

        输入：head = [1,2,3,4,5]
        输出：[1,5,2,4,3]

        提示：

        链表的长度范围为 [1, 5 * 104]
        1 <= node.val <= 1000*/
public class ReorderList143 {

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }

/*    public void reorderList(ListNode head) {
        if (head.next == null) {
            return;
        }
        Stack<ListNode> stack = new Stack<>();
        ListNode listNode = head;
        while (listNode != null) {
            stack.push(listNode);
            listNode = listNode.next;
        }
        ListNode tail = stack.pop();
        while (tail != null) {
            ListNode temp = head.next;
            // 尾节点已经是当前头节点或头节点下个节点
            if (head.equals(tail)) {
                head.next = null;
                break;
            } else if (temp.equals(tail)) {
                temp.next = null;
                break;
            }
            head.next = tail;
            tail.next = temp;
            tail = stack.pop();
            head = temp;
        }
    }*/

    public void reorderList(ListNode head) {
        if (head == null || head.next == null) {
            return;
        }
        // 使用双指针（快慢指针）慢指针指向中部
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        // 反转后半段链表
        ListNode reverse = reverse(slow.next);
        slow.next = null;

        // 合并两个链表
        merge(head, reverse);
    }

    private ListNode reverse(ListNode node) {
        ListNode prev = null, curr = node;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }

    private void merge(ListNode node1, ListNode node2) {
        while (node1 != null && node2 != null) {
            ListNode next1 = node1.next;
            node1.next = node2;
            ListNode next2 = node2.next;
            if (next1 == null) break;
            node2.next = next1;
            node1 = next1;
            node2 = next2;
        }
    }

    public static void main(String[] args) {
        ReorderList143 test = new ReorderList143();
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        test.reorderList(node1);
        // 输出：[1,4,2,3]
        printNode(node1);
    }

    public static void printNode(ListNode node) {
        while (node != null) {
            System.out.print(node.val + "->");
            node = node.next;
        }
        System.out.println();
    }
}

25. K 个一组翻转链表 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/*给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

        k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

        你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。



        示例 1：


        输入：head = [1,2,3,4,5], k = 2
        输出：[2,1,4,3,5]
        示例 2：



        输入：head = [1,2,3,4,5], k = 3
        输出：[3,2,1,4,5]


        提示：
        链表中的节点数目为 n
        1 <= k <= n <= 5000
        0 <= Node.val <= 1000


        进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？*/
public class ReverseNodesInKGroup25 {

    public ListNode reverseKGroup(ListNode head, int k) {
        // 假节点作为首节点
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;

        while (head != null) {
            ListNode tail = prev;
            // 检测是否有k个可以反转的节点，tail会指向k后的节点
            for (int i = 0; i < k; i++) {
                tail = tail.next;
                if (tail == null) {
                    // 不足k
                    return dummy.next;
                }
            }

            ListNode nextGroup = tail.next;
            // 反转当前组head到tail之间的k个节点
            ListNode[] reversed = reverse(head, tail);
            head = reversed[0];
            tail = reversed[1];

            // 将反转组和链表剩余的节点连接
            prev.next = head;
            tail.next = nextGroup;

            // 指向后面的节点
            prev = tail;
            head = nextGroup;
        }

        // O(n) O(1)
        return dummy.next;
    }

    private ListNode[] reverse(ListNode head, ListNode tail) {
        // 反转head到tail之间的节点，并返回两个节点
        // A B C D E  head = A tail = D
        ListNode prev = tail.next; // E
        ListNode curr = head; // A
        while (prev != tail) {
            ListNode nextTemp = curr.next; // B
            // A 指向 E
            curr.next = prev;
            // A作为新的尾节点
            prev = curr;
            // B作为新的头节点
            curr = nextTemp;
        }
        return new ListNode[] { tail, head };
    }

    public static void main(String[] args) {
        ReverseNodesInKGroup25 solution = new ReverseNodesInKGroup25();

        // Test Case 1
        ListNode head1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        int k1 = 2;
        ListNode result1 = solution.reverseKGroup(head1, k1);
        printList(result1); // Output: 2 1 4 3 5

        // Test Case 2
        ListNode head2 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        int k2 = 3;
        ListNode result2 = solution.reverseKGroup(head2, k2);
        printList(result2); // Output: 3 2 1 4 5
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }

        @Override
        public String toString() {
            return val + "";
        }
    }
}

19. 删除链表的倒数第 N 个结点 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/*给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

        示例 1：

        输入：head = [1,2,3,4,5], n = 2
        输出：[1,2,3,5]
        示例 2：

        输入：head = [1], n = 1
        输出：[]
        示例 3：

        输入：head = [1,2], n = 1
        输出：[1]

        提示：

        链表中结点的数目为 sz
        1 <= sz <= 30
        0 <= Node.val <= 100
        1 <= n <= sz*/
public class RemoveNthNodeFromEndOfList19 {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //// 假节点作为首节点
        //ListNode dummy = new ListNode(0);
        //dummy.next = head;
        //ListNode curr = head;
        //
        //// 将节点都入栈
        //Deque<ListNode> stack = new ArrayDeque<>();
        //while (curr != null) {
        //    stack.push(curr);
        //    curr = curr.next;
        //}
        //
        //int i = 1;
        //ListNode prev = curr;
        //while (i <= n && !stack.isEmpty()) {
        //    curr = stack.pop();
        //    if (i == n) {
        //        // 到达删除节点
        //        if (stack.isEmpty()) {
        //            // head为要删除节点
        //            return curr.next;
        //        } else {
        //            // 中间节点为删除节点
        //            ListNode next = stack.pop();
        //            next.next = prev;
        //        }
        //    }
        //    prev = curr;
        //    i++;
        //}
        //
        //// O(n)
        //return dummy.next;
        
        // 使用快慢指针遍历链表
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode slow = dummy;
        ListNode fast = dummy;

        // 快指针先移动n个节点
        for (int i = 0; i <= n; i++) {
            if (fast == null) {
                return head;
            }
            fast = fast.next;
        }

        // 一起移动两个指针，直到快指针到达终点
        while (fast != null) {
            slow = slow.next;
            fast = fast.next;
        }

        // 慢指针指向的下个节点即为要删除的节点
        slow.next = slow.next.next;

        // O(n)
        return dummy.next;
    }

    public static void main(String[] args) {
        RemoveNthNodeFromEndOfList19 solution = new RemoveNthNodeFromEndOfList19();

        ListNode head1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        int n1 = 2;
        ListNode result1 = solution.removeNthFromEnd(head1, n1);
        printList(result1); // Output: [1,2,3,5]

        ListNode head2 = new ListNode(1);
        int n2 = 1;
        ListNode result2 = solution.removeNthFromEnd(head2, n2);
        printList(result2); // Output: []

        ListNode head3 = new ListNode(1, new ListNode(2));
        int n3 = 1;
        ListNode result3 = solution.removeNthFromEnd(head3, n3);
        printList(result3); // Output: [1]

        ListNode head4 = new ListNode(1, new ListNode(2));
        int n4 = 2;
        ListNode result4 = solution.removeNthFromEnd(head4, n4);
        printList(result4); // Output: [2]

    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }

        @Override
        public String toString() {
            return val + "";
        }
    }
}

82. 删除排序链表中的重复元素 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/*给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

        示例 1：

        输入：head = [1,2,3,3,4,4,5]
        输出：[1,2,5]
        示例 2：

        输入：head = [1,1,1,2,3]
        输出：[2,3]

        提示：

        链表中节点数目在范围 [0, 300] 内
        -100 <= Node.val <= 100
        题目数据保证链表已经按升序 排列*/
public class RemoveDuplicatesFromSortedListII82 {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        // 使用快慢指针遍历链表
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        // 指向重复节点前的节点
        ListNode prev = dummy;
        // 指向重复节点的首节点
        ListNode slow = head;
        // 指向重复节点的尾节点
        ListNode fast = head.next;

        while (fast != null) {
            int count = 0;
            while (fast != null && fast.val == slow.val) {
                fast = fast.next;
                count++;
            }

            if (count > 0) {
                // 有重复节点，删除重复节点，prev不变
                prev.next = fast;
                slow = fast;
                if (fast != null) {
                    fast = fast.next;
                }
            } else {
                // 无重复节点
                prev = prev.next;
                fast = fast.next;
                slow = slow.next;
            }
        }
        // O(n)
        return dummy.next;
    }

    public static void main(String[] args) {
        RemoveDuplicatesFromSortedListII82 solution = new RemoveDuplicatesFromSortedListII82();

        ListNode head1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(3, new ListNode(4, new ListNode(4, new ListNode(5)))))));
        ListNode result1 = solution.deleteDuplicates(head1);
        printList(result1); // Output: [1,2,5]

        ListNode head2 = new ListNode(1, new ListNode(1, new ListNode(1, new ListNode(2, new ListNode(3)))));
        ListNode result2 = solution.deleteDuplicates(head2);
        printList(result2); // Output: [2,3]

        ListNode head3 = new ListNode(1, new ListNode(1));
        ListNode result3 = solution.deleteDuplicates(head3);
        printList(result3); // Output: []
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }

        @Override
        public String toString() {
            return val + "";
        }
    }
}

61. 旋转链表 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

        示例 1：

        输入：head = [1,2,3,4,5], k = 2
        输出：[4,5,1,2,3]
        示例 2：

        输入：head = [0,1,2], k = 4
        输出：[2,0,1]

        提示：

        链表中节点的数目在范围 [0, 500] 内
        -100 <= Node.val <= 100
        0 <= k <= 2 * 109*/
public class RotateList61 {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0 || head.next == null) {
            return head;
        }

        int length = 1;
        ListNode tail = head;

        // 计算链表长度，并找到尾节点
        while (tail.next != null) {
            tail = tail.next;
            length++;
        }

        // 更新k
        k %= length;
        if (k == 0) {
            return head;
        }

        // 到新头节点的距离
        int stepsToNewHead = length - k;
        ListNode newTail = head;
        // 循环获取新的头节点和尾节点
        for (int i = 1; i < stepsToNewHead; i++) {
            newTail = newTail.next;
        }

        // 找到后更新头节点，新尾节点，旧尾节点
        ListNode newHead = newTail.next;
        newTail.next = null;
        tail.next = head;

        // O(n)
        return newHead;
    }

    public static void main(String[] args) {
        RotateList61 solution = new RotateList61();

        // Test cases
        ListNode head1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        int k1 = 2;
        ListNode rotated1 = solution.rotateRight(head1, k1);
        printList(rotated1); // Output: [4,5,1,2,3]

        ListNode head2 = new ListNode(0, new ListNode(1, new ListNode(2)));
        int k2 = 4;
        ListNode rotated2 = solution.rotateRight(head2, k2);
        printList(rotated2); // Output: [2,0,1]
    }


    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }

        @Override
        public String toString() {
            return val + "";
        }
    }
}

86. 分隔链表 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/*给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

        你应当 保留 两个分区中每个节点的初始相对位置。

        示例 1：

        输入：head = [1,4,3,2,5,2], x = 3
        输出：[1,2,2,4,3,5]
        示例 2：

        输入：head = [2,1], x = 2
        输出：[1,2]

        提示：

        链表中节点的数目在范围 [0, 200] 内
        -100 <= Node.val <= 100
        -200 <= x <= 200*/
public class PartitionList86 {
    public ListNode partition(ListNode head, int x) {
        if (head == null || head.next == null) {
            return head;
        }

        // 存储小于x的节点
        ListNode beforeHead = new ListNode(0);
        // 存储大于x的节点
        ListNode afterHead = new ListNode(0);
        ListNode before = beforeHead;
        ListNode after = afterHead;

        while (head != null) {
            if (head.val < x) {
                // 小于x放入before链表
                before.next = head;
                before = before.next;
            } else {
                // 大于x放入after链表
                after.next = head;
                after = after.next;
            }
            head = head.next;
        }

        // 将after链表连接到before链表
        after.next = null;
        before.next = afterHead.next;

        // O(n)
        return beforeHead.next;
    }

    public static void main(String[] args) {
        PartitionList86 solution = new PartitionList86();

        // Test cases
        ListNode head1 = new ListNode(1, new ListNode(4, new ListNode(3, new ListNode(2, new ListNode(5, new ListNode(2))))));
        int x1 = 3;
        ListNode partitioned1 = solution.partition(head1, x1);
        printList(partitioned1); // Output: [1,2,2,4,3,5]

        ListNode head2 = new ListNode(2, new ListNode(1));
        int x2 = 2;
        ListNode partitioned2 = solution.partition(head2, x2);
        printList(partitioned2); // Output: [1,2]
    }


    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }

        @Override
        public String toString() {
            return val + "";
        }
    }
}

146. LRU 缓存 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。
        实现 LRUCache 类：
        LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
        int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
        void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
        函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

        示例：

        输入
        ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
        [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
        输出
        [null, null, null, 1, null, -1, null, -1, 3, 4]

        解释
        LRUCache lRUCache = new LRUCache(2);
        lRUCache.put(1, 1); // 缓存是 {1=1}
        lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
        lRUCache.get(1);    // 返回 1
        lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
        lRUCache.get(2);    // 返回 -1 (未找到)
        lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
        lRUCache.get(1);    // 返回 -1 (未找到)
        lRUCache.get(3);    // 返回 3
        lRUCache.get(4);    // 返回 4


        提示：

        1 <= capacity <= 3000
        0 <= key <= 10000
        0 <= value <= 105
        最多调用 2 * 105 次 get 和 put*/
public class LruCache146 {
    class Node {
        int key;
        int value;
        Node prev;
        Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    private final int capacity;
    // 存储键值对
    private final Map<Integer, Node> map;
    // 使用双向链表维护节点的顺序，头节点 head 代表最近使用的节点，尾节点 tail 是最久未使用的节点
    private final Node head;
    private final Node tail;

    public LruCache146(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.head = new Node(-1, -1);
        this.tail = new Node(-1, -1);
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        // 如果 key 不存在于哈希表中，返回 -1。
        if (!map.containsKey(key)) {
            return -1;
        }

        // 如果 key 存在于哈希表中，获取节点，将其移动到链表头部（表示最近使用过）并返回值。
        Node node = map.get(key);
        removeNode(node);
        addToFront(node);

        return node.value;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            //如果 key 存在于哈希表中，则更新节点值，将其移动到链表头部。
            Node node = map.get(key);
            node.value = value;
            removeNode(node);
            addToFront(node);
        } else {
            //如果 key 不存在于哈希表中：
            if (map.size() == capacity) {
                //如果当前缓存已满，则删除链表尾部节点（表示最久未使用），从哈希表中删除对应项。
                Node lastNode = tail.prev;
                removeNode(lastNode);
                map.remove(lastNode.key);
            }

            //创建新节点并添加到链表头部，并在哈希表中添加对应项。
            Node newNode = new Node(key, value);
            addToFront(newNode);
            map.put(key, newNode);
        }
    }

    private void removeNode(Node node) {
        // 删除节点
        Node prevNode = node.prev;
        Node nextNode = node.next;
        prevNode.next = nextNode;
        nextNode.prev = prevNode;
    }

    private void addToFront(Node node) {
        // 将节点加到头部
        Node nextNode = head.next;
        head.next = node;
        node.prev = head;
        node.next = nextNode;
        nextNode.prev = node;
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

460. LFU缓存 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
public class LFUCache460 {
    // LFU删除最不经常使用的元素，所以要维护一个计数器，统计每个元素的使用次数。
    // 当存在平局时，应该去除 最久未使用 的键。即LRU。
    // minFreq 记录当前最小访问次数，用于快速删除 LFU 节点
    private int capacity, minFreq;
    // 存储键值对，快速访问 LFU 缓存中的 Node
    private Map<Integer, Node> keyToNode;
    // 存储访问次数对应的 双向链表，按 LRU 规则排序，用于管理相同访问次数的节点
    private Map<Integer, DoublyLinkedList> freqToList;

    class Node {
        int key, value, freq;
        Node prev, next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
            this.freq = 1;
        }
    }

    class DoublyLinkedList {
        Node head, tail;
        int size;

        public DoublyLinkedList() {
            head = new Node(-1, -1); // 哨兵头
            tail = new Node(-1, -1); // 哨兵尾
            head.next = tail;
            tail.prev = head;
            size = 0;
        }

        void addNode(Node node) { // 插入到头部（最新）
            node.next = head.next;
            node.prev = head;
            head.next.prev = node;
            head.next = node;
            size++;
        }

        void removeNode(Node node) { // 从链表移除
            node.prev.next = node.next;
            node.next.prev = node.prev;
            size--;
        }

        Node removeLast() { // 移除尾部节点（最久未使用）
            if (size > 0) {
                Node node = tail.prev;
                removeNode(node);
                return node;
            }
            return null;
        }
    }

    public LFUCache460(int capacity) {
        this.capacity = capacity;
        this.minFreq = 0;
        this.keyToNode = new HashMap<>();
        this.freqToList = new HashMap<>();
    }

    public int get(int key) {
        // O(1) 哈希表查找 + 更新频率
        if (!keyToNode.containsKey(key)) return -1;
        Node node = keyToNode.get(key);
        updateFreq(node);
        return node.value;
    }

    public void put(int key, int value) {
        // O(1) 哈希表插入 + 可能移除 LFU
        if (capacity == 0) return;

        if (keyToNode.containsKey(key)) {
            Node node = keyToNode.get(key);
            node.value = value;
            updateFreq(node);
            return;
        }

        // 缓存已满，移除 LFU 节点
        if (keyToNode.size() >= capacity) {
            removeLFUNode();
        }

        // 插入新节点
        Node newNode = new Node(key, value);
        keyToNode.put(key, newNode);
        freqToList.computeIfAbsent(1, k -> new DoublyLinkedList()).addNode(newNode);
        minFreq = 1;
    }

    private void updateFreq(Node node) {
        // 每次操作要更新频率
        // 首先从freqToList中移除旧的节点
        int freq = node.freq;
        freqToList.get(freq).removeNode(node);

        // 若当前节点是唯一最少使用节点，则要更新 minFreq，并移除freqToList的整个频率
        if (freq == minFreq && freqToList.get(freq).size == 0) {
            minFreq++;
            freqToList.remove(freq);
        }

        // 增加频率，并将新的频率关系放入freqToList，若不存在则新建双向链表
        node.freq++;
        freqToList.computeIfAbsent(node.freq, k -> new DoublyLinkedList()).addNode(node);
    }

    private void removeLFUNode() {
        // LFU已满，则移除最小使用频率中的最久未使用节点，即minFreq对应双向链表的尾节点
        DoublyLinkedList minFreqList = freqToList.get(minFreq);
        Node lfuNode = minFreqList.removeLast();
        keyToNode.remove(lfuNode.key);

        // 若minFreq是唯一节点，则移除整个freq
        if (minFreqList.size == 0) {
            freqToList.remove(minFreq);
        }
    }

    public static void main(String[] args) {
        LFUCache460 cache = new LFUCache460(2);

        cache.put(1, 1);
        cache.put(2, 2);
        System.out.println(cache.get(1)); // 返回 1
        cache.put(3, 3); // 2 被移除（因为 2 和 1 频率相同，但 1 更久未使用）
        System.out.println(cache.get(2)); // 返回 -1（已被移除）
        System.out.println(cache.get(3)); // 返回 3
        cache.put(4, 4); // 1 被移除
        System.out.println(cache.get(1)); // 返回 -1（已被移除）
        System.out.println(cache.get(3)); // 返回 3
        System.out.println(cache.get(4)); // 返回 4
    }
}

3.9 二叉树 Binary Tree

  1. 递归算法
  2. 几种遍历二叉树的方式
    • 前序、中序、后序：非递归使用栈
    • 层级遍历：非递归使用链表

104. 二叉树的最大深度 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*给定一个二叉树 root ，返回其最大深度。

        二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

        示例 1：

        输入：root = [3,9,20,null,null,15,7]
        输出：3
        示例 2：

        输入：root = [1,null,2]
        输出：2

        提示：

        树中节点的数量在 [0, 104] 区间内。
        -100 <= Node.val <= 100*/
public class MaximumDepthOfBinaryTree104 {
    public int maxDepth(TreeNode root) {
        // 1.递归实现
        //if (root == null) {
        //    return 0; // 如果根节点为空，深度为0
        //} else {
        //    // 计算左子树和右子树的深度
        //    int leftDepth = maxDepth(root.left);
        //    int rightDepth = maxDepth(root.right);
        //
        //    // 返回较大的深度再加上根节点的高度（即 1）
        //    return Math.max(leftDepth, rightDepth) + 1;
        //}
        // 2.非递归实现
        if (root == null) {
            return 0; // 如果根节点为空，深度为0
        }

        int depth = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size(); // 当前层的节点数
            depth++; // 每遍历一层深度加一

            // 遍历当前层的所有节点，并将下一层节点加入队列
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }

        return depth;
    }

    public static void main(String[] args) {
        MaximumDepthOfBinaryTree104 solution = new MaximumDepthOfBinaryTree104();

        // 创建示例二叉树
        MaximumDepthOfBinaryTree104.TreeNode root = solution.new TreeNode(3);
        root.left = solution.new TreeNode(9);
        root.right = solution.new TreeNode(20);
        root.right.left = solution.new TreeNode(15);
        root.right.right = solution.new TreeNode(7);

        // 计算最大深度并打印结果
        int depth = solution.maxDepth(root);
        System.out.println("Maximum Depth of Binary Tree: " + depth);
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

100. 相同的树 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/*给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

        如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

        示例 1：

        输入：p = [1,2,3], q = [1,2,3]
        输出：true
        示例 2：

        输入：p = [1,2], q = [1,null,2]
        输出：false
        示例 3：

        输入：p = [1,2,1], q = [1,1,2]
        输出：false

        提示：

        两棵树上的节点数目都在范围 [0, 100] 内
        -104 <= Node.val <= 104*/
public class SameTree100 {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null || q == null) {
            return p == q;
        }
        Deque<TreeNode> stack1 = new ArrayDeque<>();
        Deque<TreeNode> stack2 = new ArrayDeque<>();
        stack1.push(p);
        stack2.push(q);

        // 前序遍历二叉树p，对比同结构q
        while (!stack1.isEmpty()) {
            TreeNode node1 = stack1.pop();
            TreeNode node2 = stack2.pop();
            if (node1.val != node2.val) {
                return false;
            }

            if (node1.right != null) {
                if (node2.right == null) {
                    return false;
                } else {
                    stack1.push(node1.right);
                    stack2.push(node2.right);
                }
            } else if (node2.right != null) {
                stack2.push(node2.right);
            }

            if (node1.left != null) {
                if (node2.left == null) {
                    return false;
                } else {
                    stack1.push(node1.left);
                    stack2.push(node2.left);
                }
            } else if (node2.left != null) {
                stack2.push(node2.left);
            }
        }

        // 遍历完后如果q还有节点，则不一致
        return stack2.isEmpty();
    }

    public static void main(String[] args) {
        SameTree100 solution = new SameTree100();

        SameTree100.TreeNode p1 = solution.new TreeNode(1);
        p1.left = solution.new TreeNode(2);
        p1.right = solution.new TreeNode(3);
        SameTree100.TreeNode q1 = solution.new TreeNode(1);
        q1.left = solution.new TreeNode(2);
        q1.right = solution.new TreeNode(3);

        System.out.println(solution.isSameTree(p1, q1)); // true

        SameTree100.TreeNode p2 = solution.new TreeNode(1);
        p2.left = solution.new TreeNode(2);
        SameTree100.TreeNode q2 = solution.new TreeNode(1);
        q2.right = solution.new TreeNode(2);

        System.out.println(solution.isSameTree(p2, q2)); // false

        SameTree100.TreeNode p3 = solution.new TreeNode(1);
        p3.left = solution.new TreeNode(2);
        p3.right = solution.new TreeNode(1);
        SameTree100.TreeNode q3 = solution.new TreeNode(1);
        p3.left = solution.new TreeNode(1);
        q3.right = solution.new TreeNode(2);

        System.out.println(solution.isSameTree(p3, q3)); // false

        SameTree100.TreeNode p4 = solution.new TreeNode(1);
        SameTree100.TreeNode q4 = solution.new TreeNode(1);
        q4.right = solution.new TreeNode(2);

        System.out.println(solution.isSameTree(p4, q4)); // false
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

226. 翻转二叉树 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/*给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

        示例 1：

        输入：root = [4,2,7,1,3,6,9]
        输出：[4,7,2,9,6,3,1]
        示例 2：

        输入：root = [2,1,3]
        输出：[2,3,1]
        示例 3：

        输入：root = []
        输出：[]

        提示：

        树中节点数目范围在 [0, 100] 内
        -100 <= Node.val <= 100*/
public class InvertBinaryTree226 {
    public TreeNode invertTree(TreeNode root) {
        // 遍历二叉树，将左右子节点互换
        if (root == null) {
            return root;
        }

        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.push(root);

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return root;
    }

    public static void main(String[] args) {
        InvertBinaryTree226 solution = new InvertBinaryTree226();

        TreeNode p1 = solution.new TreeNode(4);
        p1.left = solution.new TreeNode(2);
        p1.right = solution.new TreeNode(7);
        p1.left.left = solution.new TreeNode(1);
        p1.left.right = solution.new TreeNode(3);
        p1.right.left = solution.new TreeNode(6);
        p1.right.right = solution.new TreeNode(9);


        printTree(solution.invertTree(p1)); // [4,7,2,9,6,3,1]
        System.out.println();
        TreeNode p2 = solution.new TreeNode(2);
        p2.left = solution.new TreeNode(1);
        p2.right = solution.new TreeNode(3);

        printTree(solution.invertTree(p2)); // [2,3,1]
        System.out.println();

        TreeNode p3 = null;

        printTree(solution.invertTree(p3)); // []
        System.out.println();
    }

    public static void printTree(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val + " ");
        printTree(root.left);
        printTree(root.right);
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

101. 对称二叉树 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/*给你一个二叉树的根节点 root ， 检查它是否轴对称。

        示例 1：

        输入：root = [1,2,2,3,4,4,3]
        输出：true
        示例 2：

        输入：root = [1,2,2,null,3,null,3]
        输出：false

        提示：

        树中节点数目在范围 [1, 1000] 内
        -100 <= Node.val <= 100

        进阶：你可以运用递归和迭代两种方法解决这个问题吗？*/
public class SymmetricTree101 {
    public boolean isSymmetric(TreeNode root) {
        // 递归实现
        if (root == null) {
            return true;
        }
        // O(n)，空间复杂度是 O(logN) 到 O(N)
        return isMirror(root.left, root.right);
    }

    private boolean isMirror(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        if (left == null || right == null) {
            return false;
        }
        return (left.val == right.val) &&
                isMirror(left.left, right.right) &&
                isMirror(left.right, right.left);
    }


    public static void main(String[] args) {
        SymmetricTree101 solution = new SymmetricTree101();

        TreeNode p1 = solution.new TreeNode(1);
        p1.left = solution.new TreeNode(2);
        p1.right = solution.new TreeNode(2);
        p1.left.left = solution.new TreeNode(3);
        p1.left.right = solution.new TreeNode(4);
        p1.right.left = solution.new TreeNode(4);
        p1.right.right = solution.new TreeNode(3);
        System.out.println(solution.isSymmetric(p1)); // true

        TreeNode p2 = solution.new TreeNode(1);
        p2.left = solution.new TreeNode(2);
        p2.right = solution.new TreeNode(2);
        p2.left.right = solution.new TreeNode(3);
        p2.right.right = solution.new TreeNode(3);
        System.out.println(solution.isSymmetric(p2)); // false
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

105. 从前序与中序遍历序列构造二叉树 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/*给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

        示例 1:

        输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
        输出: [3,9,20,null,null,15,7]
        示例 2:

        输入: preorder = [-1], inorder = [-1]
        输出: [-1]

        提示:

        1 <= preorder.length <= 3000
        inorder.length == preorder.length
        -3000 <= preorder[i], inorder[i] <= 3000
        preorder 和 inorder 均 无重复 元素
        inorder 均出现在 preorder
        preorder 保证 为二叉树的前序遍历序列
        inorder 保证 为二叉树的中序遍历序列*/
public class ConstructBinaryTreeFromPreorderAndInorderTraversal105 {

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length == 0 || inorder.length == 0) {
            return null;
        }
        // 递归实现
        return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    private TreeNode build(int[] preorder, int preStart, int preEnd,
                           int[] inorder, int inStart, int inEnd) {
        if (preStart > preEnd || inStart > inEnd) {
            return null;
        }

        // 获取当前根节点
        int rootValue = preorder[preStart];
        TreeNode root = new TreeNode(rootValue);

        int rootIndex = 0;
        // 遍历中序数组，获取当前根节点下标
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootValue) {
                rootIndex = i;
                break;
            }
        }

        // 左子树的大小 = 根节点下标 - 起始下标
        int leftTreeSize = rootIndex - inStart;

        // 左子树 前序数组前leftTreeSize截取到，中序数组更新结束下标为根节点前
        root.left = build(preorder, preStart + 1, preStart + leftTreeSize,
                inorder, inStart, rootIndex - 1);
        // 右子树 前序数组leftTreeSize后，中序数组更新开始下标为根节点后
        root.right = build(preorder, preStart + leftTreeSize + 1, preEnd,
                inorder, rootIndex + 1, inEnd);

        return root;
    }

    public static void main(String[] args) {
        ConstructBinaryTreeFromPreorderAndInorderTraversal105 solution = new ConstructBinaryTreeFromPreorderAndInorderTraversal105();

        int[] preorder1 = {3, 9, 20, 15, 7};
        int[] inorder1 = {9, 3, 15, 20, 7};
        TreeNode result1 = solution.buildTree(preorder1, inorder1);
        solution.printTree(result1); // Output: [3,9,20,null,null,15,7]

        System.out.println();
        int[] preorder2 = {-1};
        int[] inorder2 = {-1};
        TreeNode result2 = solution.buildTree(preorder2, inorder2);
        solution.printTree(result2); // Output: [-1]
    }

    private void printTree(TreeNode root) {
        if (root == null) {
            System.out.print("null ");
            return;
        }
        System.out.print(root.val + " ");
        printTree(root.left);
        printTree(root.right);
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

106. 从中序与后序遍历序列构造二叉树 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
/*给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

        示例 1:

        输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
        输出：[3,9,20,null,null,15,7]
        示例 2:

        输入：inorder = [-1], postorder = [-1]
        输出：[-1]

        提示:

        1 <= inorder.length <= 3000
        postorder.length == inorder.length
        -3000 <= inorder[i], postorder[i] <= 3000
        inorder 和 postorder 都由 不同 的值组成
        postorder 中每一个值都在 inorder 中
        inorder 保证是树的中序遍历
        postorder 保证是树的后序遍历*/
public class ConstructBinaryTreeFromInorderAndPostorderTraversal106 {

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if (inorder.length != postorder.length || inorder.length == 0) {
            return null;
        }

        // 遍历中序数组，存储根节点与下标的对应关系
        Map<Integer, Integer> indexMap = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {
            indexMap.put(inorder[i], i);
        }

        // 递归实现
        return build(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1, indexMap);
    }

    private TreeNode build(int[] inorder, int[] postorder, int inStart, int inEnd, int postStart, int postEnd, Map<Integer, Integer> indexMap) {
        if (inStart > inEnd || postStart > postEnd) {
            return null;
        }

        // 后序遍历的最后一个元素是树的根节点，通过这个根节点可以将中序遍历数组分成左右子树的部分
        int rootValue = postorder[postEnd];
        TreeNode root = new TreeNode(rootValue);

        // 左子树的大小 = 根节点下标 - 起始下标
        int rootIndex = indexMap.get(rootValue);
        int leftSubtreeSize = rootIndex - inStart;

        // 左子树 后序数组前leftTreeSize截取到，中序数组更新结束下标为根节点前
        root.left = build(inorder, postorder, inStart, rootIndex - 1, postStart, postStart + leftSubtreeSize - 1, indexMap);
        // 右子树 后序数组leftTreeSize后，中序数组更新开始下标为根节点后
        root.right = build(inorder, postorder, rootIndex + 1, inEnd, postStart + leftSubtreeSize, postEnd - 1, indexMap);

        return root;
    }

    public static void main(String[] args) {
        ConstructBinaryTreeFromInorderAndPostorderTraversal106 solution = new ConstructBinaryTreeFromInorderAndPostorderTraversal106();

        int[] preorder1 = {9,3,15,20,7};
        int[] inorder1 = {9,15,7,20,3};
        TreeNode result1 = solution.buildTree(preorder1, inorder1);
        solution.printTree(result1); // Output: [3,9,20,null,null,15,7]

        System.out.println();
        int[] preorder2 = {-1};
        int[] inorder2 = {-1};
        TreeNode result2 = solution.buildTree(preorder2, inorder2);
        solution.printTree(result2); // Output: [-1]
    }

    private void printTree(TreeNode root) {
        if (root == null) {
            System.out.print("null ");
            return;
        }
        System.out.print(root.val + " ");
        printTree(root.left);
        printTree(root.right);
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

117. 填充每个节点的下一个右侧节点指针 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
/*给定一个二叉树：

        struct Node {
        int val;
        Node *left;
        Node *right;
        Node *next;
        }
        填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

        初始状态下，所有 next 指针都被设置为 NULL 。

        示例 1：

        输入：root = [1,2,3,4,5,null,7]
        输出：[1,#,2,3,#,4,5,7,#]
        解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。
        示例 2：

        输入：root = []
        输出：[]

        提示：

        树中的节点数在范围 [0, 6000] 内
        -100 <= Node.val <= 100
        进阶：

        你只能使用常量级额外空间。
        使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。*/
public class PopulatingNextRightPointersInEachNodeII117 {

    public Node connect(Node root) {
        // 1.非递归，空间O(n)
        //if (root == null) {
        //    return null;
        //}
        //
        //// 存放同层节点
        //Queue<Node> queue = new LinkedList<>();
        //queue.offer(root);
        //
        //while (!queue.isEmpty()) {
        //    // 本层节点数
        //    int levelSize = queue.size();
        //    for (int i = 0; i < levelSize; i++) {
        //        Node node = queue.poll();
        //
        //        // 有右边节点，则更新next节点
        //        if (i < levelSize - 1) {
        //            node.next = queue.peek();
        //        }
        //
        //        // 先左后右将下层节点分别放入链表
        //        if (node.left != null) {
        //            queue.offer(node.left);
        //        }
        //        if (node.right != null) {
        //            queue.offer(node.right);
        //        }
        //    }
        //}
        //
        //// O(n) O(n)
        //return root;
        // 2.非递归
        // 指针指向同层开始节点
        Node levelStart = root;

        while (levelStart != null) {
            Node current = levelStart;
            // 虚拟节点，作为下一层节点的前一个节点，串联起同层的所有节点
            Node dummy = new Node(0);
            Node prev = dummy;

            while (current != null) {
                // 沿着current的子节点，横向连接
                if (current.left != null) {
                    // 有左节点，则prev更新为left
                    prev.next = current.left;
                    prev = prev.next;
                }

                if (current.right != null) {
                    // 有右节点，连接后更新为右节点
                    prev.next = current.right;
                    prev = prev.next;
                }

                // current也更新为同层后一个节点
                current = current.next;
            }

            // 当前层遍历结束后，将levelStart指针指向下一层最左侧节点
            levelStart = dummy.next;
        }

        // O(n) O(1)
        return root;
    }

    // Testing the solution
    public static void main(String[] args) {
        PopulatingNextRightPointersInEachNodeII117 solution = new PopulatingNextRightPointersInEachNodeII117();

        // Example 1
        Node root1 = solution.new Node(1);
        root1.left = solution.new Node(2);
        root1.right = solution.new Node(3);
        root1.left.left = solution.new Node(4);
        root1.left.right = solution.new Node(5);
        root1.right.right = solution.new Node(7);

        Node result1 = solution.connect(root1);
        System.out.println("Example 1:");
        solution.printNextPointers(result1);

        // Example 2
        Node root2 = null;
        Node result2 = solution.connect(root2);
        System.out.println("\nExample 2:");
        solution.printNextPointers(result2);
    }

    private void printNextPointers(Node root) {
        while (root != null) {
            Node current = root;
            while (current != null) {
                System.out.print(current.val + " ");
                current = current.next;
            }
            System.out.print("# "); // Denotes the end of a level
            root = root.left; // Move to the next level
        }
    }


    public class Node {
        public int val;
        public Node left;
        public Node right;
        public Node next;

        public Node() {}

        public Node(int _val) {
            val = _val;
        }

        public Node(int _val, Node _left, Node _right, Node _next) {
            val = _val;
            left = _left;
            right = _right;
            next = _next;
        }
    }
}

114. 二叉树展开为链表 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*给你二叉树的根结点 root ，请你将它展开为一个单链表：

        展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
        展开后的单链表应该与二叉树 先序遍历 顺序相同。

        示例 1：

        输入：root = [1,2,5,3,4,null,6]
        输出：[1,null,2,null,3,null,4,null,5,null,6]
        示例 2：

        输入：root = []
        输出：[]
        示例 3：

        输入：root = [0]
        输出：[0]

        提示：

        树中结点数在范围 [0, 2000] 内
        -100 <= Node.val <= 100*/
public class FlattenBinaryTreeToLinkedList114 {
    public void flatten(TreeNode root) {
        if (root == null) {
            return;
        }

        flatten(root.left);
        flatten(root.right);

        // 保存右子树
        TreeNode right = root.right;
        // 右指针指向左子树
        root.right = root.left;
        // 左子树设为空
        root.left = null;

        // 移动到已展开的右子树的最右边节点
        TreeNode current = root;
        while (current.right != null) {
            current = current.right;
        }

        // 将保存的右子树连接到已展开的左子树的最右边节点的右边
        current.right = right; 
    }

    // Test the implementation
    public static void main(String[] args) {
        FlattenBinaryTreeToLinkedList114 solution = new FlattenBinaryTreeToLinkedList114();

        // Example 1
        TreeNode root1 = solution.new TreeNode(1);
        root1.left = solution.new TreeNode(2, solution.new TreeNode(3), solution.new TreeNode(4));
        root1.right = solution.new TreeNode(5, null, solution.new TreeNode(6));
        solution.flatten(root1);
        printLinkedList(root1); // Output: 1 -> 2 -> 3 -> 4 -> 5 -> 6

        // Example 2
        TreeNode root2 = null;
        solution.flatten(root2); // Output: null

        // Example 3
        TreeNode root3 = solution.new TreeNode(0);
        solution.flatten(root3);
        printLinkedList(root3); // Output: 0
    }

    // Helper function to print the linked list
    private static void printLinkedList(TreeNode root) {
        while (root != null) {
            System.out.print(root.val + " -> ");
            root = root.right;
        }
        System.out.println("null");
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

112. 路径总和 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/*给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

        叶子节点 是指没有子节点的节点。

        示例 1：

        输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
        输出：true
        解释：等于目标和的根节点到叶节点路径如上图所示。
        示例 2：

        输入：root = [1,2,3], targetSum = 5
        输出：false
        解释：树中存在两条根节点到叶子节点的路径：
        (1 --> 2): 和为 3
        (1 --> 3): 和为 4
        不存在 sum = 5 的根节点到叶子节点的路径。
        示例 3：

        输入：root = [], targetSum = 0
        输出：false
        解释：由于树是空的，所以不存在根节点到叶子节点的路径。

        提示：

        树中节点的数目在范围 [0, 5000] 内
        -1000 <= Node.val <= 1000
        -1000 <= targetSum <= 1000*/
public class PathSum112 {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return false;
        }

        if (root.left == null && root.right == null && root.val == targetSum) {
            return true;
        }

        // 迭代判断二叉树是否满足条件
        boolean left = hasPathSum(root.left, targetSum - root.val);
        boolean right = hasPathSum(root.right, targetSum - root.val);

        // 任一满足即可
        return left || right;
    }

    public static void main(String[] args) {
        PathSum112 solution = new PathSum112();

        // Test cases
        TreeNode root1 = new TreeNode(5);
        root1.left = new TreeNode(4, new TreeNode(11, new TreeNode(7), new TreeNode(2)), null);
        root1.right = new TreeNode(8, new TreeNode(13), new TreeNode(4, null, new TreeNode(1)));
        int targetSum1 = 22;
        System.out.println(solution.hasPathSum(root1, targetSum1)); // Output: true

        TreeNode root2 = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        int targetSum2 = 5;
        System.out.println(solution.hasPathSum(root2, targetSum2)); // Output: false

        TreeNode root3 = null;
        int targetSum3 = 0;
        System.out.println(solution.hasPathSum(root3, targetSum3)); // Output: false
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

129. 求根节点到叶节点数字之和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
        每条从根节点到叶节点的路径都代表一个数字：

        例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
        计算从根节点到叶节点生成的 所有数字之和 。

        叶节点 是指没有子节点的节点。

        示例 1：

        输入：root = [1,2,3]
        输出：25
        解释：
        从根到叶子节点路径 1->2 代表数字 12
        从根到叶子节点路径 1->3 代表数字 13
        因此，数字总和 = 12 + 13 = 25
        示例 2：

        输入：root = [4,9,0,5,1]
        输出：1026
        解释：
        从根到叶子节点路径 4->9->5 代表数字 495
        从根到叶子节点路径 4->9->1 代表数字 491
        从根到叶子节点路径 4->0 代表数字 40
        因此，数字总和 = 495 + 491 + 40 = 1026

        提示：

        树中节点的数目在范围 [1, 1000] 内
        0 <= Node.val <= 9
        树的深度不超过 10*/
public class SumRootToLeafNumbers129 {

    public int sumNumbers(TreeNode root) {
        return dfs(root, 0);
    }

    private int dfs(TreeNode node, int currSum) {
        if (node == null) {
            return 0;
        }

        // 拼接当前节点数字
        currSum = currSum * 10 + node.val;

        // 叶子节点就返回结果数字
        if (node.left == null && node.right == null) {
            return currSum;
        }

        // 非叶子节点则递归子树
        int leftSum = dfs(node.left, currSum);
        int rightSum = dfs(node.right, currSum);

        return leftSum + rightSum;
    }

    public static void main(String[] args) {
        SumRootToLeafNumbers129 solution = new SumRootToLeafNumbers129();

        // Test cases
        TreeNode root1 = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        System.out.println(solution.sumNumbers(root1)); // Output: 25

        TreeNode root2 = new TreeNode(4, new TreeNode(9, new TreeNode(5), new TreeNode(1)), new TreeNode(0));
        System.out.println(solution.sumNumbers(root2)); // Output: 1026
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

124. 二叉树中的最大路径和 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/*二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

        路径和 是路径中各节点值的总和。

        给你一个二叉树的根节点 root ，返回其 最大路径和 。

        示例 1：

        输入：root = [1,2,3]
        输出：6
        解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6
        示例 2：

        输入：root = [-10,9,20,null,null,15,7]
        输出：42
        解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42

        提示：

        树中节点数目范围是 [1, 3 * 104]
        -1000 <= Node.val <= 1000*/
public class BinaryTreeMaximumPathSum124 {
    int maxSum = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        // 递归获取最大路径和
        maxPathSumHelper(root);
        return maxSum;
    }

    private int maxPathSumHelper(TreeNode node) {
        if (node == null) {
            return 0;
        }

        // 分别获取左子树和右子树的最大和
        int leftSum = Math.max(maxPathSumHelper(node.left), 0);
        int rightSum = Math.max(maxPathSumHelper(node.right), 0);

        // 更新当前节点的最大和
        maxSum = Math.max(maxSum, node.val + leftSum + rightSum);

        // 返回从当前节点开始的最大路径和
        return node.val + Math.max(leftSum, rightSum);
    }

    public static void main(String[] args) {
        BinaryTreeMaximumPathSum124 solution = new BinaryTreeMaximumPathSum124();

        // Test cases
        TreeNode root1 = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        System.out.println(solution.maxPathSum(root1)); // Output: 6

        TreeNode root2 = new TreeNode(-10, new TreeNode(9), new TreeNode(20, new TreeNode(15), new TreeNode(7)));
        System.out.println(solution.maxPathSum(root2)); // Output: 42
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

173. 二叉搜索树迭代器 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/*实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
        BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
        boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
        int next()将指针向右移动，然后返回指针处的数字。
        注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。

        你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

        示例：

        输入
        ["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
        [[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
        输出
        [null, 3, 7, true, 9, true, 15, true, 20, false]

        解释
        BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
        bSTIterator.next();    // 返回 3
        bSTIterator.next();    // 返回 7
        bSTIterator.hasNext(); // 返回 True
        bSTIterator.next();    // 返回 9
        bSTIterator.hasNext(); // 返回 True
        bSTIterator.next();    // 返回 15
        bSTIterator.hasNext(); // 返回 True
        bSTIterator.next();    // 返回 20
        bSTIterator.hasNext(); // 返回 False


        提示：

        树中节点的数目在范围 [1, 105] 内
        0 <= Node.val <= 106
        最多调用 105 次 hasNext 和 next 操作


        进阶：

        你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高度。*/
public class BinarySearchTreeIterator173 {
    private Stack<TreeNode> stack;

    public BinarySearchTreeIterator173(TreeNode root) {
        // BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
        stack = new Stack<>();
        leftmostInorder(root);
    }

    private void leftmostInorder(TreeNode node) {
        // 遍历节点将左子树入栈，直到叶子节点
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
    }

    public int next() {
        // 将指针向右移动，然后返回指针处的数字。
        TreeNode topNode = stack.pop();
        if (topNode.right != null) {
            leftmostInorder(topNode.right);
        }
        return topNode.val;
    }

    public boolean hasNext() {
        // 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false
        return !stack.isEmpty();
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(7);
        root.left = new TreeNode(3);
        root.right = new TreeNode(15);
        root.right.left = new TreeNode(9);
        root.right.right = new TreeNode(20);

        BinarySearchTreeIterator173 iterator = new BinarySearchTreeIterator173(root);

        System.out.println(iterator.next());    // Output: 3
        System.out.println(iterator.next());    // Output: 7
        System.out.println(iterator.hasNext()); // Output: true
        System.out.println(iterator.next());    // Output: 9
        System.out.println(iterator.hasNext()); // Output: true
        System.out.println(iterator.next());    // Output: 15
        System.out.println(iterator.hasNext()); // Output: true
        System.out.println(iterator.next());    // Output: 20
        System.out.println(iterator.hasNext()); // Output: false
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

222. 完全二叉树的节点个数 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
/*给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

        完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

        示例 1：

        输入：root = [1,2,3,4,5,6]
        输出：6
        示例 2：

        输入：root = []
        输出：0
        示例 3：

        输入：root = [1]
        输出：1

        提示：

        树中节点的数目范围是[0, 5 * 104]
        0 <= Node.val <= 5 * 104
        题目数据保证输入的树是 完全二叉树

        进阶：遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？*/
public class CountCompleteTreeNodes222 {
    public int countNodes(TreeNode root) {
        if (root == null) {
            return 0;
        }

        // 计算左右子树的高度
        int leftHeight = getLeftHeight(root);
        int rightHeight = getRightHeight(root);

        // 左右子树高度相同，二叉树完全对仗，直接返回节点数为2的leftHeight次方-1
        if (leftHeight == rightHeight) {
            return (1 << leftHeight) - 1;
        }

        // 若非完全对仗，则迭代分别获取左右子节点的节点数
        return 1 + countNodes(root.left) + countNodes(root.right);
    }

    private int getLeftHeight(TreeNode node) {
        int height = 0;
        while (node != null) {
            height++;
            node = node.left;
        }
        return height;
    }

    private int getRightHeight(TreeNode node) {
        int height = 0;
        while (node != null) {
            height++;
            node = node.right;
        }
        return height;
    }

    public static void main(String[] args) {
        CountCompleteTreeNodes222 solution = new CountCompleteTreeNodes222();

        // Test cases
        // Example 1
        TreeNode root1 = new TreeNode(1);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(3);
        root1.left.left = new TreeNode(4);
        root1.left.right = new TreeNode(5);
        root1.right.left = new TreeNode(6);

        System.out.println(solution.countNodes(root1)); // Output: 6

        // Example 2
        TreeNode root2 = null;
        System.out.println(solution.countNodes(root2)); // Output: 0

        // Example 3
        TreeNode root3 = new TreeNode(1);
        System.out.println(solution.countNodes(root3)); // Output: 1
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

236. 二叉树的最近公共祖先 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/*给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

        百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

        示例 1：


        输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
        输出：3
        解释：节点 5 和节点 1 的最近公共祖先是节点 3 。
        示例 2：


        输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
        输出：5
        解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。
        示例 3：

        输入：root = [1,2], p = 1, q = 2
        输出：1

        提示：

        树中节点数目在范围 [2, 105] 内。
        -109 <= Node.val <= 109
        所有 Node.val 互不相同 。
        p != q
        p 和 q 均存在于给定的二叉树中。*/
public class LowestCommonAncestorOfABinaryTree236 {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // DFS递归解法 O(n) O(h)
        // 如果当前节点为空，或者等于其中一个目标节点，直接返回当前节点
        if (root == null || root == p || root == q) {
            return root;
        }

        // 在左右子树中寻找目标节点
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);

        // 如果左右子树分别包含目标节点，返回当前节点
        if (left != null && right != null) {
            return root;
        }

        // 如果只有左子树或右子树包含目标节点，则返回找到的节点
        return left != null ? left : right;
    }

    public static void main(String[] args) {
        LowestCommonAncestorOfABinaryTree236 solution = new LowestCommonAncestorOfABinaryTree236();

        // 构建测试用例
        TreeNode root = new TreeNode(3);
        root.left = new TreeNode(5);
        root.right = new TreeNode(1);
        root.left.left = new TreeNode(6);
        root.left.right = new TreeNode(2);
        root.right.left = new TreeNode(0);
        root.right.right = new TreeNode(8);
        root.left.right.left = new TreeNode(7);
        root.left.right.right = new TreeNode(4);

        TreeNode p = root.left;
        TreeNode q = root.right;

        // 找到最近公共祖先
        TreeNode ancestor = solution.lowestCommonAncestor(root, p, q);
        System.out.println("Lowest Common Ancestor: " + ancestor.val);
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

3.10 二叉树层次遍历 Binary Tree Level Order Traversal

199. 二叉树的右视图 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/*给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

        示例 1:

        输入: [1,2,3,null,5,null,4]
        输出: [1,3,4]
        示例 2:

        输入: [1,null,3]
        输出: [1,3]
        示例 3:

        输入: []
        输出: []

        提示:

        二叉树的节点个数的范围是 [0,100]
        -100 <= Node.val <= 100*/
public class BinaryTreeRightSideView199 {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) return result;

        // 通过链表进行层级遍历
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (i == size - 1) {
                    // 添加最右侧节点的值
                    result.add(node.val);
                }

                // 将下层子节点加入链表
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }

        return result;
    }

    public static void main(String[] args) {
        BinaryTreeRightSideView199 solution = new BinaryTreeRightSideView199();

        TreeNode root1 = new TreeNode(1);
        root1.left = new TreeNode(2, null, new TreeNode(5));
        root1.right = new TreeNode(3, null, new TreeNode(4));
        // 获取右视图节点值列表
        List<Integer> rightView = solution.rightSideView(root1);
        System.out.println("Right Side View: " + rightView); // [1,3,4]
        
        TreeNode root2 = new TreeNode(1);
        root2.right = new TreeNode(3);
        System.out.println("Right Side View: " + solution.rightSideView(root2)); // [1,3]
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

637. 二叉树的层平均值 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/*给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

        示例 1：

        输入：root = [3,9,20,null,null,15,7]
        输出：[3.00000,14.50000,11.00000]
        解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
        因此返回 [3, 14.5, 11] 。
        示例 2:

        输入：root = [3,9,20,15,7]
        输出：[3.00000,14.50000,11.00000]

        提示：

        树中节点数量在 [1, 104] 范围内
        -231 <= Node.val <= 231 - 1*/
public class AverageOfLevelsInBinaryTree637 {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();
            double average = 0.0;
            double sum = 0.0;
            for (int i = 0;i < size;i++) {
                TreeNode node = queue.poll();
                sum += node.val;

                if (i == size - 1) {
                    average = sum / size;
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(average);
        }

        return result;
    }

    public static void main(String[] args) {
        AverageOfLevelsInBinaryTree637 solution = new AverageOfLevelsInBinaryTree637();

        TreeNode root1 = new TreeNode(3);
        root1.left = new TreeNode(9);
        root1.right = new TreeNode(20, new TreeNode(15), new TreeNode(7));
        List<Double> rightView = solution.averageOfLevels(root1);
        System.out.println("averageOfLevels: " + rightView); // [3.00000,14.50000,11.00000]

        TreeNode root2 = new TreeNode(3);
        root2.left = new TreeNode(9, new TreeNode(15), new TreeNode(7));
        root2.right = new TreeNode(20);
        System.out.println("averageOfLevels: " + solution.averageOfLevels(root2)); // [3.00000,14.50000,11.00000]
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

102. 二叉树的层序遍历 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/*给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

        示例 1：

        输入：root = [3,9,20,null,null,15,7]
        输出：[[3],[9,20],[15,7]]
        示例 2：

        输入：root = [1]
        输出：[[1]]
        示例 3：

        输入：root = []
        输出：[]

        提示：

        树中节点数目在范围 [0, 2000] 内
        -1000 <= Node.val <= 1000*/
public class BinaryTreeLevelOrderTraversal102 {
    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 size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0;i < size;i++) {
                TreeNode node = queue.poll();
                list.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }

                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(list);
        }

        return result;
    }

    public static void main(String[] args) {
        BinaryTreeLevelOrderTraversal102 solution = new BinaryTreeLevelOrderTraversal102();

        TreeNode root1 = new TreeNode(3);
        root1.left = new TreeNode(9);
        root1.right = new TreeNode(20, new TreeNode(15), new TreeNode(7));
        System.out.println("levelOrder: " + solution.levelOrder(root1)); // [[3],[9,20],[15,7]]

        TreeNode root2 = new TreeNode(1);
        System.out.println("levelOrder: " + solution.levelOrder(root2)); // [[1]]

        System.out.println("levelOrder: " + solution.levelOrder(null)); // []
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

103. 二叉树的锯齿形层序遍历 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

        示例 1：

        输入：root = [3,9,20,null,null,15,7]
        输出：[[3],[20,9],[15,7]]
        示例 2：

        输入：root = [1]
        输出：[[1]]
        示例 3：

        输入：root = []
        输出：[]

        提示：

        树中节点数目在范围 [0, 2000] 内
        -100 <= Node.val <= 100*/
public class BinaryTreeZigzagLevelOrderTraversal103 {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int direction = 1;

        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0;i < size;i++) {
                TreeNode node = queue.poll();
                if (direction > 0) {
                    // 正向
                    list.add(node.val);
                } else {
                    // 逆向
                    list.add(0, node.val);
                }

                if (node.left != null) {
                    queue.offer(node.left);
                }

                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(list);
            direction = -direction;
        }

        return result;
    }

    public static void main(String[] args) {
        BinaryTreeZigzagLevelOrderTraversal103 solution = new BinaryTreeZigzagLevelOrderTraversal103();

        TreeNode root1 = new TreeNode(3);
        root1.left = new TreeNode(9);
        root1.right = new TreeNode(20, new TreeNode(15), new TreeNode(7));
        System.out.println("zigzagLevelOrder: " + solution.zigzagLevelOrder(root1)); // [[3],[20,9],[15,7]]

        TreeNode root2 = new TreeNode(1);
        System.out.println("zigzagLevelOrder: " + solution.zigzagLevelOrder(root2)); // [[1]]

        System.out.println("zigzagLevelOrder: " + solution.zigzagLevelOrder(null)); // []

        TreeNode root4 = new TreeNode(1);
        root4.left = new TreeNode(2, new TreeNode(4), null);
        root4.right = new TreeNode(3, null, new TreeNode(5));
        System.out.println("zigzagLevelOrder: " + solution.zigzagLevelOrder(root4)); // [[1],[3,2],[4,5]]

    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

3.11 二叉搜索树 Binary Search Tree

二叉搜索树节点按中序遍历升序排列，即左子树永远小于根节点，右子树永远大于根节点。

530. 二叉搜索树的最小绝对差 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

        差值是一个正数，其数值等于两值之差的绝对值。

        示例 1：

        输入：root = [4,2,6,1,3]
        输出：1
        示例 2：

        输入：root = [1,0,48,null,null,12,49]
        输出：1

        提示：

        树中节点的数目范围是 [2, 104]
        0 <= Node.val <= 105*/
public class MinimumAbsoluteDifferenceInBst530 {
    // 中序遍历二叉搜索树来解决
    // 遍历的节点值是按升序排列的，相邻节点值之间的最小差值必然在相邻节点值之间产生。
    int minDiff = Integer.MAX_VALUE;

    // 使用一个变量 prev 来记录中序遍历中的前一个节点值
    Integer prev = null;

    public int getMinimumDifference(TreeNode root) {
        inOrderTraversal(root);
        return minDiff;
    }

    private void inOrderTraversal(TreeNode root) {
        if (root == null) return;

        // 中序遍历先搜索左子树
        inOrderTraversal(root.left);

        if (prev != null) {
            // 计算当前节点值和 prev 的差值，并更新最小差值。
            minDiff = Math.min(minDiff, root.val - prev);
        }
        // 更新 prev 为当前节点值
        prev = root.val;

        inOrderTraversal(root.right);
    }

    public static void main(String[] args) {
        MinimumAbsoluteDifferenceInBst530 solution = new MinimumAbsoluteDifferenceInBst530();

        TreeNode root1 = new TreeNode(4);
        root1.left = new TreeNode(2, new TreeNode(1), new TreeNode(3));
        root1.right = new TreeNode(6);
        System.out.println("getMinimumDifference: " + solution.getMinimumDifference(root1)); // 1

        solution.minDiff = Integer.MAX_VALUE;
        solution. prev = null;
        TreeNode root2 = new TreeNode(1);
        root2.left = new TreeNode(0);
        root2.right = new TreeNode(48, new TreeNode(12), new TreeNode(49));
        System.out.println("getMinimumDifference: " + solution.getMinimumDifference(root2)); // 1

    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

230. 二叉搜索树中第K小的元素 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/*定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。

        示例 1：

        输入：root = [3,1,4,null,2], k = 1
        输出：1
        示例 2：

        输入：root = [5,3,6,2,4,null,null,1], k = 3
        输出：3

        提示：

        树中的节点数为 n 。
        1 <= k <= n <= 104
        0 <= Node.val <= 104

        进阶：如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化算法？*/
public class KthSmallestElementInABst230 {
    public int kthSmallest(TreeNode root, int k) {

        // 中序遍历二叉搜索树
        Deque<TreeNode> stack = new ArrayDeque<>();
        TreeNode curr = root;
        
        boolean startFlag = false;
        int i = 0;

        while (curr != null || !stack.isEmpty()) {
            // 循环遍历至最左子节点
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
                startFlag = true;
            }
            
            if (startFlag) {
                i++;
            } else {
                startFlag = true;
            }
            
            curr = stack.pop();
            if (i == k) {
                return curr.val;
            }
            curr = curr.right;
        }

        return -1;
    }

    public static void main(String[] args) {
        KthSmallestElementInABst230 solution = new KthSmallestElementInABst230();

        TreeNode root1 = new TreeNode(3);
        root1.left = new TreeNode(1, null, new TreeNode(2));
        root1.right = new TreeNode(4);
        System.out.println("kthSmallest: " + solution.kthSmallest(root1, 1)); // 1

        TreeNode root2 = new TreeNode(5);
        root2.left = new TreeNode(3, new TreeNode(2, new TreeNode(1), null), new TreeNode(4));
        root2.right = new TreeNode(6);
        System.out.println("kthSmallest: " + solution.kthSmallest(root2, 3)); // 3
    }
    
    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

98. 验证二叉搜索树 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

        有效 二叉搜索树定义如下：

        节点的左子树只包含 小于 当前节点的数。
        节点的右子树只包含 大于 当前节点的数。
        所有左子树和右子树自身必须也是二叉搜索树。

        示例 1：


        输入：root = [2,1,3]
        输出：true
        示例 2：

        输入：root = [5,1,4,null,null,3,6]
        输出：false
        解释：根节点的值是 5 ，但是右子节点的值是 4 。


        提示：

        树中节点数目范围在[1, 104] 内
        -231 <= Node.val <= 231 - 1*/
public class ValidateBinarySearchTree98 {
    public boolean isValidBST(TreeNode root) {
        // 当前节点、左边界和右边界，递归实现
        return isValidBST(root, null, null);
    }

    private boolean isValidBST(TreeNode root, Integer min, Integer max) {
        if (root == null) return true;

        // 检查当前节点值是否在指定边界内
        if ((min != null && root.val <= min) || (max != null && root.val >= max)) {
            return false;
        }

        // 递归地检查左右子节点，并更新边界
        return isValidBST(root.left, min, root.val) && isValidBST(root.right, root.val, max);
    }

    public static void main(String[] args) {
        ValidateBinarySearchTree98 solution = new ValidateBinarySearchTree98();

        TreeNode root1 = new TreeNode(2);
        root1.left = new TreeNode(1);
        root1.right = new TreeNode(3);
        System.out.println("isValidBST: " + solution.isValidBST(root1)); // true

        TreeNode root2 = new TreeNode(5);
        root2.left = new TreeNode(1);
        root2.right = new TreeNode(4, new TreeNode(3), new TreeNode(6));
        System.out.println("isValidBST: " + solution.isValidBST(root2)); // false
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

3.12 图 Graph

200. 岛屿数量 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/*给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

        岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

        此外，你可以假设该网格的四条边均被水包围。

        示例 1：

        输入：grid = [
        ["1","1","1","1","0"],
        ["1","1","0","1","0"],
        ["1","1","0","0","0"],
        ["0","0","0","0","0"]
        ]
        输出：1
        示例 2：

        输入：grid = [
        ["1","1","0","0","0"],
        ["1","1","0","0","0"],
        ["0","0","1","0","0"],
        ["0","0","0","1","1"]
        ]
        输出：3


        提示：

        m == grid.length
        n == grid[i].length
        1 <= m, n <= 300
        grid[i][j] 的值为 '0' 或 '1'*/
public class NumberOfIslands200 {
    public int numIslands(char[][] grid) {
        // 通过深度优先搜索（DFS）或广度优先搜索（BFS）来解决
        if (grid == null || grid.length == 0) {
            return 0;
        }

        int rows = grid.length;
        int cols = grid[0].length;
        int count = 0;

        // 遍历整个二维网格，在遇到岛屿的起始点时进行 DFS 或 BFS，并将所有连接的岛屿标记为已访问，计数岛屿的数量
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    // 当遇到未访问过的岛屿起始点（即值为 '1' 的位置）时，进行 DFS 或 BFS，将所有连接的岛屿标记为已访问，岛屿数量加一
                    count++;
                    dfs(grid, i, j);
                }
            }
        }

        return count;
    }

    private void dfs(char[][] grid, int row, int col) {
        // 在 DFS 或 BFS 中，将当前位置标记为已访问，并探索相邻的位置，如果相邻位置为未访问的岛屿，则递归或加入队列进行下一步探索
        int rows = grid.length;
        int cols = grid[0].length;

        if (row < 0 || col < 0 || row >= rows || col >= cols || grid[row][col] != '1') {
            return;
        }

        // 标记为已访问
        grid[row][col] = '0';

        // 探索相邻的位置
        dfs(grid, row - 1, col);
        dfs(grid, row + 1, col);
        dfs(grid, row, col - 1);
        dfs(grid, row, col + 1);
    }

    public static void main(String[] args) {
        NumberOfIslands200 solution = new NumberOfIslands200();
        // 计算岛屿数量
        char[][] grid = {
                {'1', '1', '0', '0', '0'},
                {'1', '1', '0', '0', '0'},
                {'0', '0', '1', '0', '0'},
                {'0', '0', '0', '1', '1'}
        };
        int islandsCount = solution.numIslands(grid);
        System.out.println("Number of Islands: " + islandsCount);
    }
}

130. 被围绕的区域 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
/*给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

        示例 1：

        输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
        输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
        解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
        示例 2：

        输入：board = [["X"]]
        输出：[["X"]]


        提示：

        m == board.length
        n == board[i].length
        1 <= m, n <= 200
        board[i][j] 为 'X' 或 'O'*/
public class SurroundedRegions130 {
    public void solve(char[][] board) {
        if (board == null || board.length == 0 || board[0] == null || board[0].length == 0) {
            return;
        }

        int m = board.length;
        int n = board[0].length;

        // 先纵向遍历两条边，
        for (int i = 0; i < m; i++) {
            // 遇到O时深度遍历周围的O，并将其替换为A，标识其为边界
            if (board[i][0] == 'O') {
                dfs(board, i, 0);
            }
            if (board[i][n - 1] == 'O') {
                dfs(board, i, n - 1);
            }
        }

        for (int j = 0; j < n; j++) {
            if (board[0][j] == 'O') {
                dfs(board, 0, j);
            }
            if (board[m - 1][j] == 'O') {
                dfs(board, m - 1, j);
            }
        }

        // 最终遍历矩阵，将O替换为X，将A替换回O
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                } else if (board[i][j] == 'A') {
                    board[i][j] = 'O';
                }
            }
        }
    }

    private void dfs(char[][] board, int i, int j) {
        // 遇到非O顶点时返回
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != 'O') {
            return;
        }

        // 替换为A
        board[i][j] = 'A';

        // 遍历四个方向
        dfs(board, i - 1, j);
        dfs(board, i + 1, j);
        dfs(board, i, j - 1);
        dfs(board, i, j + 1);
    }

    public static void main(String[] args) {
        SurroundedRegions130 solution = new SurroundedRegions130();
        char[][] board1 = {
                {'X', 'X', 'X', 'X'},
                {'X', 'O', 'O', 'X'},
                {'X', 'X', 'O', 'X'},
                {'X', 'O', 'X', 'X'}
        };
        solution.solve(board1);
        printBoard(board1);

        char[][] board2 = {
                {'X'}
        };
        solution.solve(board2);
        printBoard(board2);
    }

    private static void printBoard(char[][] board) {
        for (char[] row : board) {
            for (char cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
}

133. 克隆图 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/*给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。

        图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。

class Node {
    public int val;
    public List<Node> neighbors;
}

测试用例格式：

        简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。

        邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。

        给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

        示例 1：

        输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
        输出：[[2,4],[1,3],[2,4],[1,3]]
        解释：
        图中有 4 个节点。
        节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
        节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
        节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
        节点 4 的值是 4，它有两个邻居：节点 1 和 3 。
        示例 2：

        输入：adjList = [[]]
        输出：[[]]
        解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。
        示例 3：

        输入：adjList = []
        输出：[]
        解释：这个图是空的，它不含任何节点。
        示例 4：

        输入：adjList = [[2],[1]]
        输出：[[2],[1]]

        提示：

        节点数不超过 100 。
        每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
        无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
        由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
        图是连通图，你可以从给定节点访问到所有节点。*/
public class CloneGraph133 {
    public Node cloneGraph(Node node) {
        if (node == null) {
            return null;
        }

        // 记录节点是否已遍历
        Map<Node, Node> visited = new HashMap<>();
        return cloneNode(node, visited);
    }

    private Node cloneNode(Node node, Map<Node, Node> visited) {
        if (visited.containsKey(node)) {
            return visited.get(node);
        }

        // 复制当前节点，并记录
        Node clone = new Node(node.val, new ArrayList<>());
        visited.put(node, clone);

        // 遍历邻接表，并复制到当前节点
        for (Node neighbor : node.neighbors) {
            // 遍历的同时，也深度复制对应节点
            clone.neighbors.add(cloneNode(neighbor, visited));
        }

        return clone;
    }

    public static void main(String[] args) {
        CloneGraph133 solution = new CloneGraph133();

        // Test case 1
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        node1.neighbors.addAll(Arrays.asList(node2, node4));
        node2.neighbors.addAll(Arrays.asList(node1, node3));
        node3.neighbors.addAll(Arrays.asList(node2, node4));
        node4.neighbors.addAll(Arrays.asList(node1, node3));

        Node clonedGraph1 = solution.cloneGraph(node1);
        System.out.println("Test case 1:");
        printGraph(clonedGraph1);

        // Test case 2
        Node node2_1 = new Node(1);
        Node node2_2 = new Node(2);
        node2_1.neighbors.add(node2_2);
        node2_2.neighbors.add(node2_1);

        Node clonedGraph2 = solution.cloneGraph(node2_1);
        System.out.println("Test case 2:");
        printGraph(clonedGraph2);
    }

    private static void printGraph(Node node) {
        Map<Node, Boolean> visited = new HashMap<>();
        Queue<Node> queue = new LinkedList<>();

        queue.offer(node);
        visited.put(node, true);

        while (!queue.isEmpty()) {
            Node current = queue.poll();
            System.out.println("Node: " + current.val);

            for (Node neighbor : current.neighbors) {
                if (!visited.containsKey(neighbor)) {
                    visited.put(neighbor, true);
                    queue.offer(neighbor);
                }
            }
        }
        System.out.println();
    }


    static class Node {
        public int val;
        public List<Node> neighbors;
        public Node() {
            val = 0;
            neighbors = new ArrayList<Node>();
        }
        public Node(int _val) {
            val = _val;
            neighbors = new ArrayList<Node>();
        }
        public Node(int _val, ArrayList<Node> _neighbors) {
            val = _val;
            neighbors = _neighbors;
        }
    }
}

399. 除法求值 <medium> ~ <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
/*给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。

        另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。

        返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -1.0 替代这个答案。

        注意：输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。

        注意：未在等式列表中出现的变量是未定义的，因此无法确定它们的答案。

        示例 1：

        输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
        输出：[6.00000,0.50000,-1.00000,1.00000,-1.00000]
        解释：
        条件：a / b = 2.0, b / c = 3.0
        问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
        结果：[6.0, 0.5, -1.0, 1.0, -1.0 ]
        注意：x 是未定义的 => -1.0
        示例 2：

        输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
        输出：[3.75000,0.40000,5.00000,0.20000]
        示例 3：

        输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
        输出：[0.50000,2.00000,-1.00000,-1.00000]

        提示：

        1 <= equations.length <= 20
        equations[i].length == 2
        1 <= Ai.length, Bi.length <= 5
        values.length == equations.length
        0.0 < values[i] <= 20.0
        1 <= queries.length <= 20
        queries[i].length == 2
        1 <= Cj.length, Dj.length <= 5
        Ai, Bi, Cj, Dj 由小写英文字母与数字组成*/
public class EvaluateDivision399 {
    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
        // 使用带权重的Union-Find数据结构，称为并查集（Disjoint Set）。
        // 时间复杂度为O(Q + E * α(V))，其中Q是查询的数量，E是图中的边的数量，α(V)是Ackermann函数的反函数，通常视为一个很小的常数。

        Map<String, Node> nodes = new HashMap<>();

        // 将每个节点表示为一个带权重的集合，遍历变量对，构建节点链表，以及映射关系，其中key为变量名
        for (int i = 0; i < equations.size(); i++) {
            // 获取当前变量对
            List<String> equation = equations.get(i);
            String sourceStr = equation.get(0);
            String destinationStr = equation.get(1);
            double value = values[i];

            // 查找并构建节点
            Node source = getOrCreateNode(nodes, sourceStr);
            Node destination = getOrCreateNode(nodes, destinationStr);

            // 使用union操作将两个集合合并，并更新权重。
            union(source, destination, value);
        }

        double[] results = new double[queries.size()];

        // 遍历问题集合
        for (int i = 0; i < queries.size(); i++) {
            List<String> query = queries.get(i);
            String sourceStr = query.get(0);
            String destinationStr = query.get(1);

            // 分别获取问题的两个节点，通过节点获取结果
            Node source = nodes.get(sourceStr);
            Node destination = nodes.get(destinationStr);

            // 通过find将集合状态更新一致，获得相同的root，否则表示元素不存在
            if (source == null || destination == null || !find(source).equals(find(destination))) {
                results[i] = -1.0;
            } else {
                results[i] = source.value / destination.value;
            }
        }

        return results;
    }

    private Node getOrCreateNode(Map<String, Node> nodes, String label) {
        if (!nodes.containsKey(label)) {
            nodes.put(label, new Node(label, 1.0));
        }
        return nodes.get(label);
    }

    private Node find(Node node) {
        // find操作找到集合的根节点，如果出现超过2层的集合就会将其恢复为2层，节点的值为除以根节点的值
        if (node.parent != node) {
            Node root = find(node.parent);
            // 更新权重
            node.value *= node.parent.value;
            // 更新根节点
            node.parent = root;
        }
        return node.parent;
    }

    private void union(Node a, Node b, double value) {
        // 如果A和B没有相同根节点，则把B的root作为新的根节点关联起来
        Node rootA = find(a);
        Node rootB = find(b);

        if (rootA != rootB) {
            rootA.parent = rootB;
            rootA.value = value * b.value / a.value;
        }
    }

    private static class Node {
        String label;
        Node parent;
        double value;

        Node(String label, double value) {
            this.label = label;
            this.parent = this;
            this.value = value;
        }
    }

    //public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
    //    // 将变量对和结果映射关系存入map，包括A/B和B/A
    //    Map<String, Map<String, Double>> graph = buildGraph(equations, values);
    //    double[] results = new double[queries.size()];
    //
    //    // DFS遍历所有问题，获得所有结果
    //    for (int i = 0; i < queries.size(); i++) {
    //        results[i] = dfs(graph, queries.get(i).get(0), queries.get(i).get(1), new HashSet<>());
    //    }
    //
    //    return results;
    //}
    //
    //private Map<String, Map<String, Double>> buildGraph(List<List<String>> equations, double[] values) {
    //    Map<String, Map<String, Double>> graph = new HashMap<>();
    //
    //    // 遍历变量对，将变量和结果存入map，
    //    for (int i = 0; i < equations.size(); i++) {
    //        String source = equations.get(i).get(0);
    //        String destination = equations.get(i).get(1);
    //        double value = values[i];
    //
    //        // <A, <B, V>>
    //        graph.computeIfAbsent(source, k -> new HashMap<>()).put(destination, value);
    //        // <B, <A, 1/V>>
    //        graph.computeIfAbsent(destination, k -> new HashMap<>()).put(source, 1.0 / value);
    //    }
    //
    //    return graph;
    //}
    //
    //private double dfs(Map<String, Map<String, Double>> graph, String start, String end, Set<String> visited) {
    //    if (!graph.containsKey(start) || !graph.containsKey(end)) {
    //        return -1.0;
    //    }
    //
    //    if (start.equals(end)) {
    //        return 1.0;
    //    }
    //
    //    visited.add(start);
    //
    //    // 获取start对应的除法映射，求A/B或A/C，找到A/B=V，前者返回V，后者再找到B/C=X，得到A/C = (A/B) * (B/C) = V*X
    //    for (Map.Entry<String, Double> neighbor : graph.get(start).entrySet()) {
    //        String nextNode = neighbor.getKey();
    //        double edgeWeight = neighbor.getValue();
    //
    //        if (!visited.contains(nextNode)) {
    //            double result = dfs(graph, nextNode, end, visited);
    //
    //            if (result != -1.0) {
    //                return result * edgeWeight;
    //            }
    //        }
    //    }
    //
    //    visited.remove(start);
    //
    //    return -1.0;
    //}

    public static void main(String[] args) {
        EvaluateDivision399 solution = new EvaluateDivision399();

        // Test case 1
        List<List<String>> equations1 = Arrays.asList(
                Arrays.asList("a", "b"),
                Arrays.asList("b", "c")
        );
        double[] values1 = {2.0, 3.0};
        List<List<String>> queries1 = Arrays.asList(
                Arrays.asList("a", "c"),
                Arrays.asList("b", "a"),
                Arrays.asList("a", "e"),
                Arrays.asList("a", "a"),
                Arrays.asList("x", "x")
        );
        double[] results1 = solution.calcEquation(equations1, values1, queries1);
        System.out.println(Arrays.toString(results1));

        // Test case 2
        List<List<String>> equations2 = Arrays.asList(
                Arrays.asList("a", "b"),
                Arrays.asList("b", "c"),
                Arrays.asList("bc", "cd")
        );
        double[] values2 = {1.5, 2.5, 5.0};
        List<List<String>> queries2 = Arrays.asList(
                Arrays.asList("a", "c"),
                Arrays.asList("c", "b"),
                Arrays.asList("bc", "cd"),
                Arrays.asList("cd", "bc")
        );
        double[] results2 = solution.calcEquation(equations2, values2, queries2);
        System.out.println(Arrays.toString(results2));

        // Test case 3
        List<List<String>> equations3 = Arrays.asList(
                Arrays.asList("a", "b")
        );
        double[] values3 = {0.5};
        List<List<String>> queries3 = Arrays.asList(
                Arrays.asList("a", "b"),
                Arrays.asList("b", "a"),
                Arrays.asList("a", "c"),
                Arrays.asList("x", "y")
        );
        double[] results3 = solution.calcEquation(equations3, values3, queries3);
        System.out.println(Arrays.toString(results3));
    }
}

207. 课程表 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/*你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

        在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程  bi 。

        例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
        请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

        示例 1：

        输入：numCourses = 2, prerequisites = [[1,0]]
        输出：true
        解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
        示例 2：

        输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
        输出：false
        解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。


        提示：

        1 <= numCourses <= 2000
        0 <= prerequisites.length <= 5000
        prerequisites[i].length == 2
        0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对 互不相同*/
public class CourseSchedule207 {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 使用深度优先搜索来检测图中是否有环
        List<List<Integer>> adjacencyList = new ArrayList<>();
        int[] visited = new int[numCourses];

        // 构建邻接表
        for (int i = 0; i < numCourses; i++) {
            adjacencyList.add(new ArrayList<>());
        }

        for (int[] prerequisite : prerequisites) {
            int course = prerequisite[0];
            int prerequisiteCourse = prerequisite[1];
            adjacencyList.get(prerequisiteCourse).add(course);
        }

        // 对于每个节点，DFS遍历其邻接节点。如果在DFS遍历的过程中发现了正在访问的节点，说明存在环，返回false。如果DFS遍历完成，将该节点标记为已访问，返回true
        for (int i = 0; i < numCourses; i++) {
            if (visited[i] == 0 && !dfs(adjacencyList, visited, i)) {
                return false;
            }
        }

        return true;
    }

    private boolean dfs(List<List<Integer>> adjacencyList, int[] visited, int course) {
        if (visited[course] == 1) {
            return false; // 发现环，返回 false
        }

        if (visited[course] == 2) {
            return true; // 已访问过，返回 true
        }

        visited[course] = 1; // 标记为正在访问

        for (int nextCourse : adjacencyList.get(course)) {
            if (!dfs(adjacencyList, visited, nextCourse)) {
                return false;
            }
        }

        visited[course] = 2; // 标记为已访问
        return true;
    }

/*    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 拓扑排序
        // 创建了一个邻接表来表示图
        List<List<Integer>> adjacencyList = new ArrayList<>();
        // 并计算每个节点（课程）的入度
        int[] inDegrees = new int[numCourses];

        // 为每个课程创建一个数组
        for (int i = 0; i < numCourses; i++) {
            adjacencyList.add(new ArrayList<>());
        }

        // 遍历课程关系，将每个需要课程的作为前置的课程放入数组
        for (int[] prerequisite : prerequisites) {
            int course = prerequisite[0];
            int prerequisiteCourse = prerequisite[1];
            adjacencyList.get(prerequisiteCourse).add(course);
            inDegrees[course]++;
        }

        // 将入度为0的课程先加入链表
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inDegrees[i] == 0) {
                queue.offer(i);
            }
        }

        // 若没有入度为0的课程，直接失败
        while (!queue.isEmpty()) {

            // 获取可以直接学的课程
            int currentCourse = queue.poll();
            // 课程数-1表示需要判断能否学习的课程少1
            numCourses--;

            // 遍历需要该课程作为前置课程的后续课程，并将其入度-1，如果减为0，表示该课程也可以直接学习，将其加入链表
            for (int nextCourse : adjacencyList.get(currentCourse)) {
                if (--inDegrees[nextCourse] == 0) {
                    queue.offer(nextCourse);
                }
            }
        }

        // 如果所有课程都可以被访问（入度减为0），则可以完成所有课程，函数返回true；否则返回false。
        // 时间复杂度：O(V + E)，其中V是课程的数量（节点数），E是先修关系的数量（边数）。
        // 空间复杂度：O(V + E)，同样考虑到邻接表和visited数组。
        return numCourses == 0;
    }*/


    public static void main(String[] args) {
        CourseSchedule207 solution = new CourseSchedule207();

        // Test cases
        int numCourses1 = 2;
        int[][] prerequisites1 = {{1, 0}};
        System.out.println(solution.canFinish(numCourses1, prerequisites1)); // Output: true

        int numCourses2 = 2;
        int[][] prerequisites2 = {{1, 0}, {0, 1}};
        System.out.println(solution.canFinish(numCourses2, prerequisites2)); // Output: false
    }
}

210. 课程表 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/*现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修 bi 。

        例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。
        返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

        示例 1：

        输入：numCourses = 2, prerequisites = [[1,0]]
        输出：[0,1]
        解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
        示例 2：

        输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
        输出：[0,2,1,3]
        解释：总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
        因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
        示例 3：

        输入：numCourses = 1, prerequisites = []
        输出：[0]


        提示：
        1 <= numCourses <= 2000
        0 <= prerequisites.length <= numCourses * (numCourses - 1)
        prerequisites[i].length == 2
        0 <= ai, bi < numCourses
ai != bi
        所有[ai, bi] 互不相同*/
public class CourseScheduleII210 {

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        List<List<Integer>> adjacencyList = new ArrayList<>();
        int[] indegree = new int[numCourses];
        int[] result = new int[numCourses];
        int index = 0;

        for (int i = 0; i < numCourses; i++) {
            adjacencyList.add(new ArrayList<>());
        }

        for (int[] prerequisite : prerequisites) {
            int course = prerequisite[0];
            int prerequisiteCourse = prerequisite[1];
            adjacencyList.get(prerequisiteCourse).add(course);
            indegree[course]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0) {
                queue.offer(i);
            }
        }

        while (!queue.isEmpty()) {
            int currentCourse = queue.poll();
            result[index++] = currentCourse;

            for (int nextCourse : adjacencyList.get(currentCourse)) {
                indegree[nextCourse]--;
                if (indegree[nextCourse] == 0) {
                    queue.offer(nextCourse);
                }
            }
        }

        return index == numCourses ? result : new int[0];
    }

    public static void main(String[] args) {
        CourseScheduleII210 solution = new CourseScheduleII210();

        // 测试用例
        int numCourses1 = 2;
        int[][] prerequisites1 = {{1, 0}};
        System.out.println(Arrays.toString(solution.findOrder(numCourses1, prerequisites1))); // 输出: [0, 1]

        int numCourses2 = 4;
        int[][] prerequisites2 = {{1, 0}, {2, 0}, {3, 1}, {3, 2}};
        System.out.println(Arrays.toString(solution.findOrder(numCourses2, prerequisites2))); // 输出: [0, 2, 1, 3]

        int numCourses3 = 1;
        int[][] prerequisites3 = {};
        System.out.println(Arrays.toString(solution.findOrder(numCourses3, prerequisites3))); // 输出: [0]
    }
}

3.13 图的广度优先搜索 Breadth-First Search (BFS) in Graphs

909. 蛇梯棋 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/*给你一个大小为 n x n 的整数矩阵 board ，方格按从 1 到 n2 编号，编号遵循 转行交替方式 ，从左下角开始 （即，从 board[n - 1][0] 开始）每一行交替方向。

        玩家从棋盘上的方格 1 （总是在最后一行、第一列）开始出发。

        每一回合，玩家需要从当前方格 curr 开始出发，按下述要求前进：

        选定目标方格 next ，目标方格的编号符合范围 [curr + 1, min(curr + 6, n2)] 。
        该选择模拟了掷 六面体骰子 的情景，无论棋盘大小如何，玩家最多只能有 6 个目的地。
        传送玩家：如果目标方格 next 处存在蛇或梯子，那么玩家会传送到蛇或梯子的目的地。否则，玩家传送到目标方格 next 。
        当玩家到达编号 n2 的方格时，游戏结束。
        r 行 c 列的棋盘，按前述方法编号，棋盘格中可能存在 “蛇” 或 “梯子”；如果 board[r][c] != -1，那个蛇或梯子的目的地将会是 board[r][c]。编号为 1 和 n2 的方格上没有蛇或梯子。

        注意，玩家在每回合的前进过程中最多只能爬过蛇或梯子一次：就算目的地是另一条蛇或梯子的起点，玩家也 不能 继续移动。

        举个例子，假设棋盘是 [[-1,4],[-1,3]] ，第一次移动，玩家的目标方格是 2 。那么这个玩家将会顺着梯子到达方格 3 ，但 不能 顺着方格 3 上的梯子前往方格 4 。
        返回达到编号为 n2 的方格所需的最少移动次数，如果不可能，则返回 -1。

        示例 1：

        输入：board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]
        输出：4
        解释：
        首先，从方格 1 [第 5 行，第 0 列] 开始。
        先决定移动到方格 2 ，并必须爬过梯子移动到到方格 15 。
        然后决定移动到方格 17 [第 3 行，第 4 列]，必须爬过蛇到方格 13 。
        接着决定移动到方格 14 ，且必须通过梯子移动到方格 35 。
        最后决定移动到方格 36 , 游戏结束。
        可以证明需要至少 4 次移动才能到达最后一个方格，所以答案是 4 。
        示例 2：

        输入：board = [[-1,-1],[-1,3]]
        输出：1

        提示：

        n == board.length == board[i].length
        2 <= n <= 20
        grid[i][j] 的值是 -1 或在范围 [1, n2] 内
        编号为 1 和 n2 的方格上没有蛇或梯子*/
public class SnakesAndLadders909 {

    public int snakesAndLadders(int[][] board) {
        // 将棋盘上的每个方格看作图中的节点，根据规则构建图，然后使用BFS计算从起点到终点的最短路径。
        int n = board.length;
        int target = n * n;

        Queue<Integer> queue = new LinkedList<>();
        boolean[] visited = new boolean[target + 1];

        queue.offer(1);
        visited[1] = true;
        // 计算多少次移动
        int moves = 0;

        // 在BFS的过程中，通过模拟骰子的掷动，计算每个节点的相邻节点。如果相邻节点对应的方格上有蛇或梯子，需要将玩家传送到蛇或梯子的目的地。
        while (!queue.isEmpty()) {
            int size = queue.size();

            for (int i = 0; i < size; i++) {
                int current = queue.poll();

                if (current == target) {
                    return moves;
                }

                // 遍历一轮骰子能到达的距离
                for (int next = current + 1; next <= Math.min(current + 6, target); next++) {

                    // 将num转为二维的行列坐标，获取
                    int[] coordinates = getCoordinates(next, n);
                    int row = coordinates[0];
                    int col = coordinates[1];

                    // 获取下一个方格的编号，-1表示没有梯子或蛇，否则通过board获取传送的位置
                    int nextVal = board[row][col] == -1 ? next : board[row][col];

                    // 记录未访问过的顶点
                    if (!visited[nextVal]) {
                        visited[nextVal] = true;
                        queue.offer(nextVal);
                    }
                }
            }

            moves++;
        }

        return -1;
    }

    private int[] getCoordinates(int num, int n) {
        // 将方格编号映射到对应的行和列坐标,将一维编号映射到二维坐标，方便后续在二维数组中进行操作。
        // 方格的编号 num 和棋盘的大小 n，返回一个包含两个元素的整数数组，分别表示方格的行坐标和列坐标。

        // 分别计算行号和列号
        int row = (num - 1) / n;
        int col = (num - 1) % n;

        if (row % 2 == 1) {
            // 由于行号为奇数时，列号需要进行翻转，所以对于奇数行，将 col 置为 n - 1 - col
            col = n - 1 - col;
        }

        // 返回的数组中，n - 1 - row 表示转换后的行坐标，col 表示列坐标
        return new int[]{n - 1 - row, col};
    }

    public static void main(String[] args) {
        SnakesAndLadders909 solution = new SnakesAndLadders909();

        // 测试用例
        int[][] board1 = {
                {-1, -1, -1, -1, -1, -1},
                {-1, -1, -1, -1, -1, -1},
                {-1, -1, -1, -1, -1, -1},
                {-1, 35, -1, -1, 13, -1},
                {-1, -1, -1, -1, -1, -1},
                {-1, 15, -1, -1, -1, -1}
        };
        System.out.println(solution.snakesAndLadders(board1)); // 输出: 4

        int[][] board2 = {
                {-1, -1},
                {-1, 3}
        };
        System.out.println(solution.snakesAndLadders(board2)); // 输出: 1
    }
}

433. 最小基因变化 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/*基因序列可以表示为一条由 8 个字符组成的字符串，其中每个字符都是 'A'、'C'、'G' 和 'T' 之一。

        假设我们需要调查从基因序列 start 变为 end 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。

        例如，"AACCGGTT" --> "AACCGGTA" 就是一次基因变化。
        另有一个基因库 bank 记录了所有有效的基因变化，只有基因库中的基因才是有效的基因序列。（变化后的基因必须位于基因库 bank 中）

        给你两个基因序列 start 和 end ，以及一个基因库 bank ，请你找出并返回能够使 start 变化为 end 所需的最少变化次数。如果无法完成此基因变化，返回 -1 。

        注意：起始基因序列 start 默认是有效的，但是它并不一定会出现在基因库中。

        示例 1：

        输入：start = "AACCGGTT", end = "AACCGGTA", bank = ["AACCGGTA"]
        输出：1
        示例 2：

        输入：start = "AACCGGTT", end = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
        输出：2
        示例 3：

        输入：start = "AAAAACCC", end = "AACCCCCC", bank = ["AAAACCCC","AAACCCCC","AACCCCCC"]
        输出：3

        提示：

        start.length == 8
        end.length == 8
        0 <= bank.length <= 10
        bank[i].length == 8
        start、end 和 bank[i] 仅由字符 ['A', 'C', 'G', 'T'] 组成*/
public class MinimumGeneticMutation433 {

    public int minMutation(String startGene, String endGene, String[] bank) {
        // 使用 BFS 进行搜索，每一层代表一次基因变化
        Set<String> bankSet = new HashSet<>(Arrays.asList(bank));
        if (!bankSet.contains(endGene)) {
            // 要变化的基因不在基因库
            return -1;
        }

        char[] geneChars = {'A', 'C', 'G', 'T'};
        // 使用集合 visited 记录已经访问过的基因，避免重复搜索。
        Set<String> visited = new HashSet<>();
        Queue<String> queue = new LinkedList<>();
        queue.offer(startGene);
        visited.add(startGene);

        int steps = 0;

        while (!queue.isEmpty()) {
            int size = queue.size();

            for (int i = 0; i < size; i++) {
                String currentGene = queue.poll();
                // 已变化出end基因，返回当前次数
                if (currentGene.equals(endGene)) {
                    return steps;
                }

                // 从起始基因开始，将其每个字符替换为其他可能的字符，检查是否在基因库中，如果在则将该新基因加入队列。
                char[] currentChars = currentGene.toCharArray();
                for (int j = 0; j < currentChars.length; j++) {
                    char originalChar = currentChars[j];
                    // 依次尝试替换当前char，然后判断是否为基因库或已重复
                    for (char newChar : geneChars) {
                        currentChars[j] = newChar;
                        String newGene = new String(currentChars);
                        if (!visited.contains(newGene) && bankSet.contains(newGene)) {
                            // 基因库的新变型
                            queue.offer(newGene);
                            visited.add(newGene);
                        }
                    }
                    // 恢复回原基因
                    currentChars[j] = originalChar;
                }
            }
            steps++;
        }

        // O(n)
        return -1;
    }
    
    public static void main(String[] args) {
        MinimumGeneticMutation433 solution = new MinimumGeneticMutation433();

        // Test Case 1
        String start1 = "AACCGGTT";
        String end1 = "AACCGGTA";
        String[] bank1 = {"AACCGGTA"};
        System.out.println(solution.minMutation(start1, end1, bank1)); // Output: 1

        // Test Case 2
        String start2 = "AACCGGTT";
        String end2 = "AAACGGTA";
        String[] bank2 = {"AACCGGTA", "AACCGCTA", "AAACGGTA"};
        System.out.println(solution.minMutation(start2, end2, bank2)); // Output: 2

        // Test Case 3
        String start3 = "AAAAACCC";
        String end3 = "AACCCCCC";
        String[] bank3 = {"AAAACCCC", "AAACCCCC", "AACCCCCC"};
        System.out.println(solution.minMutation(start3, end3, bank3)); // Output: 3
    }
}

127. 单词接龙 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/*字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> ... -> sk：

        每一对相邻的单词只差一个字母。
        对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中。
        sk == endWord
        给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回 从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。

        示例 1：

        输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
        输出：5
        解释：一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。
        示例 2：

        输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
        输出：0
        解释：endWord "cog" 不在字典中，所以无法进行转换。

        提示：

        1 <= beginWord.length <= 10
        endWord.length == beginWord.length
        1 <= wordList.length <= 5000
        wordList[i].length == beginWord.length
        beginWord、endWord 和 wordList[i] 由小写英文字母组成
        beginWord != endWord
        wordList 中的所有字符串 互不相同*/
public class WordLadder127 {

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // 使用 BFS 进行搜索，每一层代表一次单词变化
        Set<String> wordSet = new HashSet<>(wordList);
        if (!wordSet.contains(endWord)) {
            return 0;
        }

        Queue<String> queue = new LinkedList<>();
        Set<String> visited = new HashSet<>();
        queue.offer(beginWord);
        visited.add(beginWord);

        int steps = 1;

        while (!queue.isEmpty()) {
            int size = queue.size();


            // 从起始单词开始，将其每个字符替换为其他可能的字符，检查是否在字典中，如果在则将该新单词加入队列
            for (int i = 0; i < size; i++) {
                String currentWord = queue.poll();
                char[] wordChars = currentWord.toCharArray();

                // 依次替换单词的每个字符
                for (int j = 0; j < wordChars.length; j++) {
                    char originalChar = wordChars[j];
                    // 依次从a替换到z
                    for (char c = 'a'; c <= 'z'; c++) {
                        if (c == originalChar) {
                            continue;
                        }
                        wordChars[j] = c;
                        String newWord = new String(wordChars);
                        // 字典存在的单词，若为新单词就继续遍历
                        if (wordSet.contains(newWord)) {
                            if (newWord.equals(endWord)) {
                                // 找到要转换的单词
                                return steps + 1;
                            }
                            if (!visited.contains(newWord)) {
                                queue.offer(newWord);
                                visited.add(newWord);
                            }
                        }
                    }
                    wordChars[j] = originalChar;
                }
            }
            // 该层所有能转换的单词都无法命中endWord，层数+1
            steps++;
        }

        // O(m * n)
        return 0;
    }

    public static void main(String[] args) {
        WordLadder127 solution = new WordLadder127();

        // Test Case 1
        String beginWord1 = "hit";
        String endWord1 = "cog";
        List<String> wordList1 = Arrays.asList("hot", "dot", "dog", "lot", "log", "cog");
        System.out.println(solution.ladderLength(beginWord1, endWord1, wordList1)); // Output: 5

        // Test Case 2
        String beginWord2 = "hit";
        String endWord2 = "cog";
        List<String> wordList2 = Arrays.asList("hot", "dot", "dog", "lot", "log");
        System.out.println(solution.ladderLength(beginWord2, endWord2, wordList2)); // Output: 0
    }
}

3.14 字典树 Trie (Prefix Tree)

208. 实现 Trie (前缀树) <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/*Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

        请你实现 Trie 类：

        Trie() 初始化前缀树对象。
        void insert(String word) 向前缀树中插入字符串 word 。
        boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
        boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

        示例：

        输入
        ["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
        [[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
        输出
        [null, null, true, false, true, null, true]

        解释
        Trie trie = new Trie();
        trie.insert("apple");
        trie.search("apple");   // 返回 True
        trie.search("app");     // 返回 False
        trie.startsWith("app"); // 返回 True
        trie.insert("app");
        trie.search("app");     // 返回 True

        提示：

        1 <= word.length, prefix.length <= 2000
        word 和 prefix 仅由小写英文字母组成
        insert、search 和 startsWith 调用次数 总计 不超过 3 * 104 次*/
public class ImplementTriePrefixTree208 {
/**
 * Your Trie object will be instantiated and called as such:
 * Trie obj = new Trie();
 * obj.insert(word);
 * boolean param_2 = obj.search(word);
 * boolean param_3 = obj.startsWith(prefix);
 */
    // 使用 TrieNode 类表示 Trie 树的节点，其中包含一个数组 children 存储子节点和一个标志 isEnd 表示是否是单词的结束
    private TrieNode root;

    public ImplementTriePrefixTree208() {
        this.root = new TrieNode();
    }

    // 插入单词
    public void insert(String word) {
        TrieNode node = root;
        // 遍历单词的每个字符，逐级建立 Trie 树的节点
        for (char ch : word.toCharArray()) {
            int index = ch - 'a';
            if (node.children[index] == null) {
                node.children[index] = new TrieNode();
            }
            node = node.children[index];
        }
        node.isEnd = true;
    }

    // 搜索单词
    public boolean search(String word) {
        // 遍历单词的每个字符，查找是否存在对应的 Trie 节点，并判断最后一个节点是否是单词的结束
        TrieNode node = searchPrefix(word);
        return node != null && node.isEnd;
    }

    // 搜索前缀的方法
    public boolean startsWith(String prefix) {
        // 遍历前缀的每个字符，查找是否存在对应的 Trie 节点，不需要判断是否是单词的结束
        return searchPrefix(prefix) != null;
    }

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

    public static void main(String[] args) {
        // insert、search、startsWith 操作的时间复杂度均为 O(m)，其中 m 为单词长度。
        // Trie 树的空间复杂度为 O(26 * m * n)，其中 m 为单词长度，n 为单词数量。
        ImplementTriePrefixTree208 trie = new ImplementTriePrefixTree208();

        // Test Case 1
        trie.insert("apple");
        System.out.println(trie.search("apple"));   // Output: true
        System.out.println(trie.search("app"));     // Output: false
        System.out.println(trie.startsWith("app")); // Output: true
        trie.insert("app");
        System.out.println(trie.search("app"));     // Output: true

        // Test Case 2
        trie = new ImplementTriePrefixTree208();
        System.out.println(trie.search("a"));   // Output: false
    }

    public static class TrieNode {

        TrieNode[] children;
        boolean isEnd;

        public TrieNode() {
            this.children = new TrieNode[26];
            this.isEnd = false;
        }
    }
}

211. 添加与搜索单词 - 数据结构设计 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/*请你设计一个数据结构，支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。

        实现词典类 WordDictionary ：

        WordDictionary() 初始化词典对象
        void addWord(word) 将 word 添加到数据结构中，之后可以对它进行匹配
        bool search(word) 如果数据结构中存在字符串与 word 匹配，则返回 true ；否则，返回  false 。word 中可能包含一些 '.' ，每个 . 都可以表示任何一个字母。

        示例：

        输入：
        ["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
        [[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
        输出：
        [null,null,null,null,false,true,true,true]

        解释：
        WordDictionary wordDictionary = new WordDictionary();
        wordDictionary.addWord("bad");
        wordDictionary.addWord("dad");
        wordDictionary.addWord("mad");
        wordDictionary.search("pad"); // 返回 False
        wordDictionary.search("bad"); // 返回 True
        wordDictionary.search(".ad"); // 返回 True
        wordDictionary.search("b.."); // 返回 True

        提示：

        1 <= word.length <= 25
        addWord 中的 word 由小写英文字母组成
        search 中的 word 由 '.' 或小写英文字母组成
        最多调用 104 次 addWord 和 search*/
public class DesignAddAndSearchWordsDataStructure211 {
    // 使用 TrieNode 类表示 Trie 树的节点，其中包含一个数组 children 存储子节点和一个标志 isEnd 表示是否是单词的结束
    private TrieNode root;

    public DesignAddAndSearchWordsDataStructure211() {
        this.root = new TrieNode();
    }

    public void addWord(String word) {
        // 将每个字符分别构建对应的node
        TrieNode node = root;
        for (char ch : word.toCharArray()) {
            int index = ch - 'a';
            if (node.children[index] == null) {
                node.children[index] = new TrieNode();
            }
            node = node.children[index];
        }
        node.isEnd = true;
    }

    public boolean search(String word) {
        return searchWord(root, word, 0);
    }

    private boolean searchWord(TrieNode node, String word, int index) {
        if (index == word.length()) {
            // 全部命中返回true
            return node.isEnd;
        }

        char ch = word.charAt(index);
        if (ch == '.') {
            // .任意字符，找到一个非空子节点继续
            for (TrieNode child : node.children) {
                if (child != null && searchWord(child, word, index + 1)) {
                    return true;
                }
            }
        } else {
            // 若命中就继续
            int charIndex = ch - 'a';
            if (node.children[charIndex] != null) {
                return searchWord(node.children[charIndex], word, index + 1);
            }
        }
        return false;
    }

    public static void main(String[] args) {
        DesignAddAndSearchWordsDataStructure211 wordDictionary = new DesignAddAndSearchWordsDataStructure211();

        // Test Case 1
        wordDictionary.addWord("bad");
        wordDictionary.addWord("dad");
        wordDictionary.addWord("mad");
        System.out.println(wordDictionary.search("pad")); // Output: false
        System.out.println(wordDictionary.search("bad")); // Output: true
        System.out.println(wordDictionary.search(".ad")); // Output: true
        System.out.println(wordDictionary.search("b..")); // Output: true

        // Test Case 2
        wordDictionary = new DesignAddAndSearchWordsDataStructure211();
        wordDictionary.addWord("a");
        wordDictionary.addWord("a");
        System.out.println(wordDictionary.search(".a")); // Output: false
        System.out.println(wordDictionary.search("a.")); // Output: false
        System.out.println(wordDictionary.search("a")); // Output: true
    }

    class TrieNode {
        TrieNode[] children;
        boolean isEnd;

        public TrieNode() {
            this.children = new TrieNode[26];
            this.isEnd = false;
        }
    }

}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */

212. 单词搜索 II <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words， 返回所有二维网格上的单词 。

        单词必须按照字母顺序，通过 相邻的单元格 内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。

        示例 1：

        输入：board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]
        输出：["eat","oath"]
        示例 2：

        输入：board = [["a","b"],["c","d"]], words = ["abcb"]
        输出：[]

        提示：

        m == board.length
        n == board[i].length
        1 <= m, n <= 12
        board[i][j] 是一个小写英文字母
        1 <= words.length <= 3 * 104
        1 <= words[i].length <= 10
        words[i] 由小写英文字母组成
        words 中的所有字符串互不相同*/
public class WordSearchII212 {
    public List<String> findWords(char[][] board, String[] words) {
        List<String> result = new ArrayList<>();
        TrieNode root = buildTrie(words);

        // 遍历二维字符网格，对每个字符进行 DFS 搜索，检查是否构成 Trie 中的单词。
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                dfs(board, i, j, root, result);
            }
        }

        // 最终返回所有找到的单词列表。
        return result;
    }

    private TrieNode buildTrie(String[] words) {
        // 使用 Trie 树建立单词字典，将单词按照字母序插入 Trie 中。
        TrieNode root = new TrieNode();

        for (String word : words) {
            TrieNode node = root;
            for (char ch : word.toCharArray()) {
                int index = ch - 'a';
                if (node.children[index] == null) {
                    node.children[index] = new TrieNode();
                }
                node = node.children[index];
            }
            node.word = word;
        }

        return root;
    }

    private void dfs(char[][] board, int i, int j, TrieNode node, List<String> result) {
        char ch = board[i][j];
        if (ch == '#' || node.children[ch - 'a'] == null) {
            return;
        }

        // 获取字典树对应节点
        node = node.children[ch - 'a'];
        if (node.word != null) {
            // 为避免重复结果，将已经找到的单词从 Trie 中删除。
            result.add(node.word);
            node.word = null;
        }

        board[i][j] = '#'; // Mark visited

        // 分别遍历四个方向
        if (i > 0) dfs(board, i - 1, j, node, result);
        if (i < board.length - 1) dfs(board, i + 1, j, node, result);
        if (j > 0) dfs(board, i, j - 1, node, result);
        if (j < board[0].length - 1) dfs(board, i, j + 1, node, result);

        // 复原
        board[i][j] = ch;
    }

    public static void main(String[] args) {
        // 假设字典中所有单词总长度为 L，board 为 m x n 的网格：
        // Trie 树的构建时间复杂度为 O(L)。
        // 遍历网格的 DFS 搜索时间复杂度为 O(m * n * L)。
        // 总体时间复杂度为 O(m * n * L)。
        // Trie 树的空间复杂度为 O(L)
        WordSearchII212 solution = new WordSearchII212();

        // Test Case 1
        char[][] board1 = {
                {'o', 'a', 'a', 'n'},
                {'e', 't', 'a', 'e'},
                {'i', 'h', 'k', 'r'},
                {'i', 'f', 'l', 'v'}
        };
        String[] words1 = {"oath", "pea", "eat", "rain"};
        List<String> result1 = solution.findWords(board1, words1);
        System.out.println(result1);  // Output: ["eat", "oath"]

        // Test Case 2
        char[][] board2 = {
                {'a', 'b'},
                {'c', 'd'}
        };
        String[] words2 = {"abcb"};
        List<String> result2 = solution.findWords(board2, words2);
        System.out.println(result2);  // Output: []
    }

    class TrieNode {
        TrieNode[] children;
        String word;

        public TrieNode() {
            this.children = new TrieNode[26];
            this.word = null;
        }
    }
}

3.15 回溯 Backtracking

回溯算法的基本思路：

  1. 选择： 在每一步，根据问题的要求，做出一个选择，决定接下来的路径。这个选择可能是从一组可能的选项中选择一个，也可能是决定一个变量的取值，或者其他类似的决策。
  2. 路径： 记录选择构成的路径，通常使用递归调用的栈来保存路径。路径中的每一步都对应了一个选择。
  3. 条件： 确定在当前状态下是否满足问题的条件，即当前路径是否是问题的解。如果满足，就终止递归，得到一个解；如果不满足，进行回溯。
  4. 回溯： 当已经考虑过当前选择，并且发现不能继续扩展出有效解时，需要进行回溯。回溯是撤销当前选择，返回到上一步，尝试其他的可能性。

在回溯算法的实现中，经常使用递归函数来实现深度优先搜索。递归函数包括选择、路径记录、条件判断和回溯这几个重要的步骤。

一般用于排列组合问题等。

顶层调用函数：

1
2
3
4
5
6
7
8
9
10
11
12
public List<List<Integer>> permute(int[] nums) {
    // 最终结果集合
    List<List<Integer>> result = new ArrayList<>();
    // 当前结果
    List<Integer> current = new ArrayList<>();
    // 全排列时使用标识集合
    boolean[] used = new boolean[nums.length];
    backtrack(nums, used, current, result);
    // 非全排列时，增加一个索引标识起点
    backtrack(nums, 0 or 1, current, result);
    return result;
}

回溯算法：

  • 非全排列：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    private void backtrack(int[] nums, int target, int start, List<Integer> current, List<List<Integer>> result) {
        // {条件}
        if (target == 0) {
            result.add(new ArrayList<>(current));
            return;
        }
      
        // 非全排列标记一个起点，若元素能重复，则递归仍为i，否则为i+1
        for (int i = start; i < nums.length; i++) {
            current.add(nums[i]);
            // 递归可以重复当前元素
            backtrack(nums, target - nums[i], i, current, result);
            // {回溯}
            current.remove(current.size() - 1);
        }
    }

  • 全排列：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    private void backtrack(int[] nums, boolean[] used, List<Integer> current, List<List<Integer>> result) {
        // {条件}
        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current));
            return;
        }
      
        // 全排列时每次递归都重新遍历集合，跳过已被使用的元素，在回溯时可以在上层加入靠后元素，在下层加入靠前元素
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                // 从0开始，依次加入nums.length个元素
                current.add(nums[i]);
                used[i] = true;
                backtrack(nums, used, current, result);
                // {回溯}
                used[i] = false;
                current.remove(current.size() - 1);
            }
        }
    }

17. 电话号码的字母组合 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/*给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

        给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

        示例 1：

        输入：digits = "23"
        输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
        示例 2：

        输入：digits = ""
        输出：[]
        示例 3：

        输入：digits = "2"
        输出：["a","b","c"]


        提示：

        0 <= digits.length <= 4
        digits[i] 是范围 ['2', '9'] 的一个数字。*/
public class LetterCombinationsOfAPhoneNumber17 {

    public List<String> letterCombinations(String digits) {
        List<String> result = new ArrayList<>();
        if (digits == null || digits.length() == 0) {
            return result;
        }

        // 初始化每个数字对应的字母集合
        Map<Character, String> phoneMap = initializePhoneMap();
        // 使用回溯算法，遍历数字字符串的每个数字，根据数字映射得到对应的字母集合。
        backtrack(digits, 0, new StringBuilder(), phoneMap, result);

        return result;
    }

    private void backtrack(String digits, int index, StringBuilder current, Map<Character, String> phoneMap, List<String> result) {
        if (index == digits.length()) {
            // 将每次深度优先搜索得到的组合加入结果集。
            result.add(current.toString());
            return;
        }

        // 逐个组合字母，深度优先搜索，直到达到数字字符串的末尾。
        char digit = digits.charAt(index);
        String letters = phoneMap.get(digit);
        for (char letter : letters.toCharArray()) {
            current.append(letter);
            backtrack(digits, index + 1, current, phoneMap, result);
            current.deleteCharAt(current.length() - 1);
        }
    }

    private Map<Character, String> initializePhoneMap() {
        Map<Character, String> phoneMap = new HashMap<>();
        phoneMap.put('2', "abc");
        phoneMap.put('3', "def");
        phoneMap.put('4', "ghi");
        phoneMap.put('5', "jkl");
        phoneMap.put('6', "mno");
        phoneMap.put('7', "pqrs");
        phoneMap.put('8', "tuv");
        phoneMap.put('9', "wxyz");
        return phoneMap;
    }

    public static void main(String[] args) {
        // 时间复杂度：对于每个数字，最坏情况下需要遍历其对应的字母集合，因此时间复杂度为 O(3^N * 4^M)，其中 N 和 M 分别表示 digits 中对应 3 个和 4 个字母的数字的数量。
        // 空间复杂度：除了返回值外，递归调用栈的最大深度为 digits 的长度，因此空间复杂度为 O(N)，其中 N 表示 digits 的长度。
        LetterCombinationsOfAPhoneNumber17 solution = new LetterCombinationsOfAPhoneNumber17();

        // Test Case 1
        String digits1 = "23";
        List<String> result1 = solution.letterCombinations(digits1);
        System.out.println(result1);  // Output: ["ad","ae","af","bd","be","bf","cd","ce","cf"]

        // Test Case 2
        String digits2 = "";
        List<String> result2 = solution.letterCombinations(digits2);
        System.out.println(result2);  // Output: []

        // Test Case 3
        String digits3 = "2";
        List<String> result3 = solution.letterCombinations(digits3);
        System.out.println(result3);  // Output: ["a","b","c"]
    }
}

77. 组合 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/*给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

        你可以按 任何顺序 返回答案。

        示例 1：

        输入：n = 4, k = 2
        输出：
        [
        [2,4],
        [3,4],
        [2,3],
        [1,2],
        [1,3],
        [1,4],
        ]
        示例 2：

        输入：n = 1, k = 1
        输出：[[1]]

        提示：

        1 <= n <= 20
        1 <= k <= n*/
public class Combinations77 {
    public List<List<Integer>> combine(int n, int k) {
        // 主要的思路是从1到n逐个尝试作为组合的起始元素，然后递归地向后查找剩余的元素。
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> current = new ArrayList<>();
        backtrack(n, k, 1, current, result);
        return result;
    }

    private void backtrack(int n, int k, int start, List<Integer> current, List<List<Integer>> result) {
        // 在递归的过程中，需要注意设置递归的终止条件，即已经选取了k个元素。
        if (current.size() == k) {
            result.add(new ArrayList<>(current));
            return;
        }

        // 先加入当前start，然后递归加入剩余k-1个元素，每次都移除最后一个元素，然后加入新元素
        for (int i = start; i <= n; i++) {
            current.add(i);
            backtrack(n, k, i + 1, current, result);
            // 每次递归选择一个元素后，需要将其从当前组合中移除，以便尝试其他组合。
            current.remove(current.size() - 1);
        }
    }

    public static void main(String[] args) {
        //由于需要遍历所有可能的组合，时间复杂度为O(C(n, k))，其中C(n, k)表示从n个元素中选择k个的组合数。
        //空间复杂度为O(k)，主要用于存储递归过程中的当前组合。
        Combinations77 solution = new Combinations77();

        // Test Case 1
        int n1 = 4, k1 = 2;
        List<List<Integer>> result1 = solution.combine(n1, k1);
        System.out.println(result1);
        // Output: [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

        // Test Case 2
        int n2 = 1, k2 = 1;
        List<List<Integer>> result2 = solution.combine(n2, k2);
        System.out.println(result2);
        // Output: [[1]]
    }
}

46. 全排列 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/*给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

        示例 1：

        输入：nums = [1,2,3]
        输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
        示例 2：

        输入：nums = [0,1]
        输出：[[0,1],[1,0]]
        示例 3：

        输入：nums = [1]
        输出：[[1]]


        提示：

        1 <= nums.length <= 6
        -10 <= nums[i] <= 10
        nums 中的所有整数 互不相同*/
public class Permutations46 {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> current = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        backtrack(nums, used, current, result);
        return result;
    }

    private void backtrack(int[] nums, boolean[] used, List<Integer> current, List<List<Integer>> result) {
        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current));
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            // 每次递归都重新遍历集合，跳过已被使用的元素，在回溯时可以在上层加入靠后元素，在下层加入靠前元素
            if (!used[i]) {
                // 从0开始，依次加入nums.length个元素
                current.add(nums[i]);
                used[i] = true;
                backtrack(nums, used, current, result);
                // 恢复状态
                used[i] = false;
                current.remove(current.size() - 1);
            }
        }
    }

    public static void main(String[] args) {
        Permutations46 solution = new Permutations46();

        // Test Case 1
        int[] nums1 = {1, 2, 3};
        List<List<Integer>> result1 = solution.permute(nums1);
        System.out.println(result1);
        // Output: [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

        // Test Case 2
        int[] nums2 = {0, 1};
        List<List<Integer>> result2 = solution.permute(nums2);
        System.out.println(result2);
        // Output: [[0, 1], [1, 0]]

        // Test Case 3
        int[] nums3 = {1};
        List<List<Integer>> result3 = solution.permute(nums3);
        System.out.println(result3);
        // Output: [[1]]
    }
}

39. 组合总和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/*给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

        candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

        对于给定的输入，保证和为 target 的不同组合数少于 150 个。

        示例 1：

        输入：candidates = [2,3,6,7], target = 7
        输出：[[2,2,3],[7]]
        解释：
        2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
        7 也是一个候选， 7 = 7 。
        仅有这两种组合。
        示例 2：

        输入: candidates = [2,3,5], target = 8
        输出: [[2,2,2,2],[2,3,3],[3,5]]
        示例 3：

        输入: candidates = [2], target = 1
        输出: []

        提示：

        1 <= candidates.length <= 30
        2 <= candidates[i] <= 40
        candidates 的所有元素 互不相同
        1 <= target <= 40*/
public class CombinationSum39 {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> current = new ArrayList<>();
        backtrack(candidates, target, 0, current, result);
        return result;
    }

    private void backtrack(int[] candidates, int target, int start, List<Integer> current, List<List<Integer>> result) {
        if (target == 0) {
            result.add(new ArrayList<>(current));
            return;
        }

        for (int i = start; i < candidates.length; i++) {
            if (candidates[i] <= target) {
                current.add(candidates[i]);
                // 递归可以重复当前元素
                backtrack(candidates, target - candidates[i], i, current, result);
                current.remove(current.size() - 1);
            }
        }
    }

    public static void main(String[] args) {
        CombinationSum39 solution = new CombinationSum39();

        // Test Case 1
        int[] candidates1 = {2, 3, 6, 7};
        int target1 = 7;
        List<List<Integer>> result1 = solution.combinationSum(candidates1, target1);
        System.out.println(result1);
        // Output: [[2, 2, 3], [7]]

        // Test Case 2
        int[] candidates2 = {2, 3, 5};
        int target2 = 8;
        List<List<Integer>> result2 = solution.combinationSum(candidates2, target2);
        System.out.println(result2);
        // Output: [[2, 2, 2, 2], [2, 3, 3], [3, 5]]

        // Test Case 3
        int[] candidates3 = {2};
        int target3 = 1;
        List<List<Integer>> result3 = solution.combinationSum(candidates3, target3);
        System.out.println(result3);
        // Output: []
    }
}

52. N 皇后 II <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/*n 皇后问题 研究的是如何将 n 个皇后放置在 n × n 的棋盘上，并且使皇后彼此之间不能相互攻击。

        给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。

        示例 1：

        输入：n = 4
        输出：2
        解释：如上图所示，4 皇后问题存在两个不同的解法。
        示例 2：

        输入：n = 1
        输出：1

        提示：

        1 <= n <= 9*/
public class NQueensII52 {
    public int totalNQueens(int n) {
        // 用数组包装结果，方便在递归中修改
        int[] result = {0};

        // 集合下标和值分别对应行列
        int[] queens = new int[n];

        // 填充集合
        Arrays.fill(queens, -1);

        // 在递归的过程中，每次选择一个合适的位置放置皇后，然后进入下一行的递归。如果某一行找不到合适的位置，则需要回溯到上一行，尝试其他位置，直到找到所有合适的位置或者递归结束。
        solveNQueens(queens, n, 0, result);

        return result[0];
    }

    private void solveNQueens(int[] queens, int n, int row, int[] result) {
        // 递归结束，结果+1，回溯
        if (row == n) {
            result[0]++;
            return;
        }

        for (int col = 0; col < n; col++) {
            // 为了避免皇后互相攻击，需要检查当前位置是否与之前的皇后位置冲突
            if (isValid(queens, row, col)) {
                queens[row] = col;
                solveNQueens(queens, n, row + 1, result);
                // 回溯复原
                queens[row] = -1;
            }
        }
    }

    private boolean isValid(int[] queens, int row, int col) {
        // 遍历皇后集合，检查同一列、同一行以及对角线上是否有皇后
        for (int i = 0; i < row; i++) {
            if (queens[i] == col || Math.abs(queens[i] - col) == Math.abs(i - row)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        // 时间复杂度为O(N!)，其中N为棋盘边长。
        // 空间复杂度为O(N)，主要用于存储每行皇后的位置。
        NQueensII52 solution = new NQueensII52();

        // Test Case 1
        int n1 = 4;
        int result1 = solution.totalNQueens(n1);
        System.out.println(result1);
        // Output: 2

        // Test Case 2
        int n2 = 1;
        int result2 = solution.totalNQueens(n2);
        System.out.println(result2);
        // Output: 1
    }
}

22. 括号生成 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

        示例 1：

        输入：n = 3
        输出：["((()))","(()())","(())()","()(())","()()()"]
        示例 2：

        输入：n = 1
        输出：["()"]

        提示：

        1 <= n <= 8*/
public class GenerateParentheses22 {
    public List<String> generateParenthesis(int n) {
        List<String> result = new ArrayList<>();
        generateParenthesisHelper("", 0, 0, n, result);
        return result;
    }

    private void generateParenthesisHelper(String current, int open, int close, int n, List<String> result) {
        // 满足条件
        if (current.length() == 2 * n) {
            result.add(current);
            return;
        }

        // 左括号先递归
        if (open < n) {
            generateParenthesisHelper(current + '(', open + 1, close, n, result);
        }
        // 右括号递归，不能先于左括号出现
        if (close < open) {
            generateParenthesisHelper(current + ')', open, close + 1, n, result);
        }
    }

    public static void main(String[] args) {
        GenerateParentheses22 solution = new GenerateParentheses22();

        // Test Case 1
        int n1 = 3;
        List<String> result1 = solution.generateParenthesis(n1);
        System.out.println(result1);
        // Output: ["((()))","(()())","(())()","()(())","()()()"]

        // Test Case 2
        int n2 = 1;
        List<String> result2 = solution.generateParenthesis(n2);
        System.out.println(result2);
        // Output: ["()"]
    }
}

79. 单词搜索 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
/*给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

        单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

        示例 1：

        输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
        输出：true
        示例 2：

        输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
        输出：true
        示例 3：

        输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
        输出：false

        提示：

        m == board.length
        n = board[i].length
        1 <= m, n <= 6
        1 <= word.length <= 15
        board 和 word 仅由大小写英文字母组成

        进阶：你可以使用搜索剪枝的技术来优化解决方案，使其在 board 更大的情况下可以更快解决问题？*/
public class WordSearch79 {
    public boolean exist(char[][] board, String word) {
        int m = board.length;
        int n = board[0].length;

        // 遍历整个二维字符网格
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 在递归的过程中，需要进行剪枝，即在遍历的过程中标记已经访问过的位置，并在递归结束后恢复标记。
                if (dfs(board, word, i, j, 0)) {
                    return true;
                }
            }
        }

        return false;
    }

    private boolean dfs(char[][] board, String word, int i, int j, int k) {
        // 递归终止条件，超边界 or 字符不匹配
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != word.charAt(k)) {
            return false;
        }

        // 当前字符匹配，且已经匹配到最后一个字符
        if (k == word.length() - 1) {
            return true;
        }

        // 临时标记当前位置已访问
        char temp = board[i][j];
        board[i][j] = '/';

        // 递归遍历四个方向
        boolean result = dfs(board, word, i + 1, j, k + 1) ||
                dfs(board, word, i - 1, j, k + 1) ||
                dfs(board, word, i, j + 1, k + 1) ||
                dfs(board, word, i, j - 1, k + 1);

        // 恢复当前位置字符
        board[i][j] = temp;

        return result;
    }

    public static void main(String[] args) {
        WordSearch79 solution = new WordSearch79();

        // Test Case 1
        char[][] board1 = {
                {'A', 'B', 'C', 'E'},
                {'S', 'F', 'C', 'S'},
                {'A', 'D', 'E', 'E'}
        };
        String word1 = "ABCCED";
        boolean result1 = solution.exist(board1, word1);
        System.out.println(result1);
        // Output: true

        // Test Case 2
        char[][] board2 = {
                {'A', 'B', 'C', 'E'},
                {'S', 'F', 'C', 'S'},
                {'A', 'D', 'E', 'E'}
        };
        String word2 = "SEE";
        boolean result2 = solution.exist(board2, word2);
        System.out.println(result2);
        // Output: true

        // Test Case 3
        char[][] board3 = {
                {'A', 'B', 'C', 'E'},
                {'S', 'F', 'C', 'S'},
                {'A', 'D', 'E', 'E'}
        };
        String word3 = "ABCB";
        boolean result3 = solution.exist(board3, word3);
        System.out.println(result3);
        // Output: false
    }
}

3.16 分治 Divide and Conquer

分治思想：分治是将一个大问题分割成多个相同或相似的子问题，递归地解决这些子问题，然后合并其结果，得到原问题的解。

分治思想通常包含三个步骤：

  1. 分解（Divide）： 将原问题分解成若干个规模较小、相对独立且与原问题形式相同的子问题。
  2. 解决（Conquer）： 递归地解决这些子问题。如果子问题规模足够小，直接求解。
  3. 合并（Combine）： 将子问题的解合并成原问题的解。

分治算法通常应用于可以被划分为相互独立的子问题，并且子问题的结构和整体问题相似的情况。它常被用来解决复杂度较高的问题，尤其在递归实现时可以显著降低问题的规模。

分治算法的运用场景：

  1. 排序算法： 归并排序和快速排序都是基于分治思想的排序算法。
  2. 搜索问题： 二分查找是分治思想的一个经典例子。
  3. 最大子数组问题： 通过将问题分解为左子数组、右子数组和跨越中点的子数组，并在这三者中找到最大值，从而解决整体问题。
  4. 大整数乘法： 将大整数分解为两半，递归地计算各自的乘积，然后合并结果。
  5. 快速傅里叶变换（FFT）： 在信号处理和图像处理领域中广泛使用的一种算法，它利用分治思想高效计算多项式的离散傅里叶变换。

经典分治算法例子：

  1. 归并排序（Merge Sort）： 将数组一分为二，递归地对两个子数组进行排序，然后将有序的子数组合并成一个有序数组。
  2. 快速排序（Quick Sort）： 选择一个基准元素，将数组分为两部分，分别递归地对两部分进行排序，然后合并。
  3. 二分查找： 在有序数组中查找目标元素，每次将查找范围一分为二，逐步缩小范围直到找到目标或范围为空。

分治算法的优缺点：

优点：

  1. 结构清晰，易于理解和实现。
  2. 并行化的可能性，因为子问题相互独立。

缺点：

  1. 递归和合并步骤可能会引入额外的时间和空间开销。
  2. 对于一些问题，划分子问题的代价可能较高。

参考题目：

  1. 归并排序： LeetCode 148. Sort List
  2. 快速排序： LeetCode 912. Sort an Array
  3. 二分查找： LeetCode 704. Binary Search
  4. 最大子数组问题： LeetCode 53. Maximum Subarray
  5. 大整数乘法： LeetCode 43. Multiply Strings

108. 将有序数组转换为二叉搜索树 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/*给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

        高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

        示例 1：

        输入：nums = [-10,-3,0,5,9]
        输出：[0,-3,9,-10,null,5]
        解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

        示例 2：

        输入：nums = [1,3]
        输出：[3,1]
        解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

        提示：

        1 <= nums.length <= 104
        -104 <= nums[i] <= 104
        nums 按 严格递增 顺序排列*/
public class ConvertSortedArrayToBinarySearchTree108 {
    public TreeNode sortedArrayToBST(int[] nums) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        return buildBST(nums, 0, nums.length - 1);
    }

    private TreeNode buildBST(int[] nums, int left, int right) {
        if (left > right) {
            return null;
        }

        // 由于数组已经按照升序排列，我们可以选择数组的中间元素作为根节点，然后递归地对左右两个子数组分别构建左右子树，直到整个数组构建完毕。
        int mid = left + (right - left) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = buildBST(nums, left, mid - 1);
        root.right = buildBST(nums, mid + 1, right);

        return root;
    }

    public static void main(String[] args) {
        // 每个节点都会被访问一次，因此时间复杂度是O(n)，其中n是数组的长度。
        // 递归调用的深度是树的高度，平均情况下为O(log n)，最坏情况下为O(n)（当树退化为链表时）。
        ConvertSortedArrayToBinarySearchTree108 solution = new ConvertSortedArrayToBinarySearchTree108();

        // Test Case 1
        int[] nums1 = {-10, -3, 0, 5, 9};
        TreeNode result1 = solution.sortedArrayToBST(nums1);
        System.out.println(result1.val);
        // Output: [0,-3,9,-10,null,5]

        // Test Case 2
        int[] nums2 = {1, 3};
        TreeNode result2 = solution.sortedArrayToBST(nums2);
        System.out.println(result2.val);
        // Output: [3,1]
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

148. 排序链表 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
/*给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

        示例 1：

        输入：head = [4,2,1,3]
        输出：[1,2,3,4]
        示例 2：

        输入：head = [-1,5,3,4,0]
        输出：[-1,0,3,4,5]
        示例 3：

        输入：head = []
        输出：[]

        提示：

        链表中节点的数目在范围 [0, 5 * 104] 内
        -105 <= Node.val <= 105

        进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？*/
public class SortList148 {
    public ListNode sortList(ListNode head) {
        // 使用归并排序的思想，将链表不断划分成两半，递归地对左右两半进行排序，最后合并两个有序链表
        if (head == null || head.next == null) {
            return head;
        }

        ListNode mid = findMiddle(head);
        // 递归切割左边
        ListNode left = sortList(head);
        // 递归切割右边
        ListNode right = sortList(mid);

        // 升序合并两个链表
        return merge(left, right);
    }

    private ListNode findMiddle(ListNode head) {
        // 快慢指针，快指针是慢指针的两倍速度
        ListNode slow = head;
        ListNode fast = head;
        ListNode prev = null;

        while (fast != null && fast.next != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }

        // prev指向slow指针，即链表中间，将链表截断
        if (prev != null) {
            prev.next = null;
        }

        return slow;
    }

    private ListNode merge(ListNode left, ListNode right) {
        ListNode dummy = new ListNode();
        ListNode current = dummy;

        // 同时遍历两个链表
        while (left != null && right != null) {
            // 用current指向小的节点，将两个链表连在一起
            if (left.val < right.val) {
                current.next = left;
                left = left.next;
            } else {
                current.next = right;
                right = right.next;
            }
            current = current.next;
        }

        // 连上剩余的最大值
        if (left != null) {
            current.next = left;
        }

        if (right != null) {
            current.next = right;
        }

        return dummy.next;
    }

    private ListNode createLinkedList(int[] values) {
        ListNode dummy = new ListNode();
        ListNode current = dummy;

        for (int value : values) {
            current.next = new ListNode(value);
            current = current.next;
        }

        return dummy.next;
    }

    private void printLinkedList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }

    public static void main(String[] args) {
        // 每次递归划分链表，时间复杂度为O(log n)，每次合并两个有序链表的时间复杂度为O(n)，总体时间复杂度为O(n log n)
        // 递归调用的深度为O(log n)，因此空间复杂度为O(log n)
        SortList148 solution = new SortList148();

        // Test Case 1
        ListNode head1 = solution.createLinkedList(new int[]{4, 2, 1, 3});
        ListNode result1 = solution.sortList(head1);
        solution.printLinkedList(result1);
        // Output: [1,2,3,4]

        // Test Case 2
        ListNode head2 = solution.createLinkedList(new int[]{-1, 5, 3, 4, 0});
        ListNode result2 = solution.sortList(head2);
        solution.printLinkedList(result2);
        // Output: [-1,0,3,4,5]

        // Test Case 3
        ListNode head3 = solution.createLinkedList(new int[]{});
        ListNode result3 = solution.sortList(head3);
        solution.printLinkedList(result3);
        // Output: []
    }
}

427. 建立四叉树 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*给你一个 n * n 矩阵 grid ，矩阵由若干 0 和 1 组成。请你用四叉树表示该矩阵 grid 。

        你需要返回能表示矩阵 grid 的 四叉树 的根结点。

        四叉树数据结构中，每个内部节点只有四个子节点。此外，每个节点都有两个属性：

        val：储存叶子结点所代表的区域的值。1 对应 True，0 对应 False。注意，当 isLeaf 为 False 时，你可以把 True 或者 False 赋值给节点，两种值都会被判题机制 接受 。
        isLeaf: 当这个节点是一个叶子结点时为 True，如果它有 4 个子节点则为 False 。
class Node {
    public boolean val;
    public boolean isLeaf;
    public Node topLeft;
    public Node topRight;
    public Node bottomLeft;
    public Node bottomRight;
}
我们可以按以下步骤为二维区域构建四叉树：

        如果当前网格的值相同（即，全为 0 或者全为 1），将 isLeaf 设为 True ，将 val 设为网格相应的值，并将四个子节点都设为 Null 然后停止。
        如果当前网格的值不同，将 isLeaf 设为 False， 将 val 设为任意值，然后如下图所示，将当前网格划分为四个子网格。
        使用适当的子网格递归每个子节点。


        如果你想了解更多关于四叉树的内容，可以参考 wiki 。

        四叉树格式：

        你不需要阅读本节来解决这个问题。只有当你想了解输出格式时才会这样做。输出为使用层序遍历后四叉树的序列化形式，其中 null 表示路径终止符，其下面不存在节点。

        它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 [isLeaf, val] 。

        如果 isLeaf 或者 val 的值为 True ，则表示它在列表 [isLeaf, val] 中的值为 1 ；如果 isLeaf 或者 val 的值为 False ，则表示值为 0 。

        示例 1：

        输入：grid = [[0,1],[1,0]]
        输出：[[0,1],[1,0],[1,1],[1,1],[1,0]]
        解释：此示例的解释如下：
        请注意，在下面四叉树的图示中，0 表示 false，1 表示 True 。

        示例 2：

        输入：grid = [[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]]
        输出：[[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
        解释：网格中的所有值都不相同。我们将网格划分为四个子网格。
        topLeft，bottomLeft 和 bottomRight 均具有相同的值。
        topRight 具有不同的值，因此我们将其再分为 4 个子网格，这样每个子网格都具有相同的值。
        解释如下图所示：

        提示：

        n == grid.length == grid[i].length
        n == 2x 其中 0 <= x <= 6*/
public class ConstructQuadTree427 {

    public Node construct(int[][] grid) {
        // 给定一个由 0 和 1 组成的矩阵 grid，我们需要构建一个四叉树表示这个矩阵。四叉树的每个节点有两个属性：val 表示节点的值（0 或 1），isLeaf 表示是否为叶子节点。如果一个节点是叶子节点，则其四个子节点都为 null。
        // 构建四叉树的基本思路是递归处理，首先判断当前区域是否为叶子节点，如果是，则创建一个叶子节点，否则，将当前区域划分为四个子区域，分别递归构建四叉树。
        return build(grid, 0, 0, grid.length - 1, grid[0].length - 1);
    }

    private Node build(int[][] grid, int rowStart, int colStart, int rowEnd, int colEnd) {
        // 定义一个递归函数 build，该函数接收矩阵的左上角和右下角的坐标，然后判断当前区域是否为叶子节点。
        // 如果是叶子节点，创建一个叶子节点，将 val 设置为当前区域的值，isLeaf 设置为 true。
        // 如果不是叶子节点，计算当前区域的中心坐标 (midRow, midCol)，然后递归构建四个子区域。
        // 返回根节点。
        if (rowStart > rowEnd || colStart > colEnd) {
            return null;
        }

        // Check if the current region is a leaf
        boolean isLeaf = true;
        int val = grid[rowStart][colStart];
        for (int i = rowStart; i <= rowEnd; i++) {
            for (int j = colStart; j <= colEnd; j++) {
                if (grid[i][j] != val) {
                    isLeaf = false;
                    break;
                }
            }
        }

        // If it's a leaf, create a leaf node
        if (isLeaf) {
            return new Node(val == 1, true, null, null, null, null);
        }

        // If it's not a leaf, divide the region into four sub-regions
        int midRow = (rowStart + rowEnd) / 2;
        int midCol = (colStart + colEnd) / 2;

        Node topLeft = build(grid, rowStart, colStart, midRow, midCol);
        Node topRight = build(grid, rowStart, midCol + 1, midRow, colEnd);
        Node bottomLeft = build(grid, midRow + 1, colStart, rowEnd, midCol);
        Node bottomRight = build(grid, midRow + 1, midCol + 1, rowEnd, colEnd);

        // Create a non-leaf node
        return new Node(false, false, topLeft, topRight, bottomLeft, bottomRight);
    }

    public static void main(String[] args) {
        //在每个递归步骤中，我们对每个区域进行常数次操作，因此时间复杂度为 O(n)，其中 n 是矩阵的总元素数量。
        //递归调用的深度是 O(logn)，因此空间复杂度也是 O(logn)。
        ConstructQuadTree427 solution = new ConstructQuadTree427();

        int[][] grid1 = {{0, 1}, {1, 0}};
        Node result1 = solution.construct(grid1);
        System.out.println(result1);

        int[][] grid2 = {
                {1, 1, 1, 1, 0, 0, 0, 0},
                {1, 1, 1, 1, 0, 0, 0, 0},
                {1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 0, 0, 0, 0},
                {1, 1, 1, 1, 0, 0, 0, 0},
                {1, 1, 1, 1, 0, 0, 0, 0},
                {1, 1, 1, 1, 0, 0, 0, 0}
        };
        Node result2 = solution.construct(grid2);
        System.out.println(result2);
    }

    class Node {
        public boolean val;
        public boolean isLeaf;
        public Node topLeft;
        public Node topRight;
        public Node bottomLeft;
        public Node bottomRight;
        public Node() {}

        public Node(boolean val, boolean isLeaf, Node topLeft, Node topRight, Node bottomLeft, Node bottomRight) {
            this.val = val;
            this.isLeaf = isLeaf;
            this.topLeft = topLeft;
            this.topRight = topRight;
            this.bottomLeft = bottomLeft;
            this.bottomRight = bottomRight;
        }
    }
}

23. 合并 K 个升序链表 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*给你一个链表数组，每个链表都已经按升序排列。

        请你将所有链表合并到一个升序链表中，返回合并后的链表。

        示例 1：

        输入：lists = [[1,4,5],[1,3,4],[2,6]]
        输出：[1,1,2,3,4,4,5,6]
        解释：链表数组如下：
        [
        1->4->5,
        1->3->4,
        2->6
        ]
        将它们合并到一个有序链表中得到。
        1->1->2->3->4->4->5->6
        示例 2：

        输入：lists = []
        输出：[]
        示例 3：

        输入：lists = [[]]
        输出：[]

        提示：

        k == lists.length
        0 <= k <= 10^4
        0 <= lists[i].length <= 500
        -10^4 <= lists[i][j] <= 10^4
        lists[i] 按 升序 排列
        lists[i].length 的总和不超过 10^4*/
public class MergeKSortedLists23 {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        
        // 创建一个小顶堆，堆中的元素为链表的头结点：使用优先队列（PriorityQueue）来维护链表的头结点，每次取出最小的结点进行合并。
        PriorityQueue<ListNode> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a.val));


        // 遍历每个链表，将链表的头结点加入到优先队列中。
        for (ListNode list : lists) {
            if (list != null) {
                minHeap.add(list);
            }
        }

        // 使用 dummy 结点作为合并后链表的头结点
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;

        // 循环处理堆中的结点，每次取出堆顶最小结点，将其下一个结点加入堆中，直到所有链表都合并完成。
        while (!minHeap.isEmpty()) {
            ListNode minNode = minHeap.poll();
            current.next = minNode;
            current = current.next;

            if (minNode.next != null) {
                minHeap.add(minNode.next);
            }
        }

        return dummy.next;
    }

    // Helper method to create a linked list from an array
    private ListNode createList(int[] values) {
        ListNode dummy = new ListNode();
        ListNode current = dummy;
        for (int value : values) {
            current.next = new ListNode(value);
            current = current.next;
        }
        return dummy.next;
    }

    // Helper method to print a linked list
    private void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 假设所有链表的总节点数为 n，每次从优先队列中取出最小结点的时间复杂度为 O(logk)，其中 k 是链表的个数。总体时间复杂度为 O(n * logk)。
        // 优先队列中最多有 k 个节点，因此空间复杂度为 O(k)。
        MergeKSortedLists23 solution = new MergeKSortedLists23();

        // Test case 1
        int[] values1 = {1, 4, 5};
        int[] values2 = {1, 3, 4};
        int[] values3 = {2, 6};
        ListNode list1 = solution.createList(values1);
        ListNode list2 = solution.createList(values2);
        ListNode list3 = solution.createList(values3);
        ListNode[] lists1 = {list1, list2, list3};
        ListNode result1 = solution.mergeKLists(lists1);
        solution.printList(result1);

        // Test case 2
        ListNode[] lists2 = {};
        ListNode result2 = solution.mergeKLists(lists2);
        solution.printList(result2);

        // Test case 3
        ListNode[] lists3 = {null};
        ListNode result3 = solution.mergeKLists(lists3);
        solution.printList(result3);
    }

    public class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
}

3.17 Kadane算法 Kadane’s Algorithm

Kadane算法用于解决最大子数组和问题，即在一个数组中找到一个连续的子数组，使得该子数组的和最大。算法的核心思想是使用动态规划的思想，维护两个变量：

  1. currentMax: 表示以当前元素为结尾的子数组的最大和。
  2. globalMax: 表示整个数组中最大的子数组和。

算法的步骤如下：

  1. 初始化 currentMax 和 globalMax 为数组的第一个元素。
  2. 遍历数组，对于每个元素，更新 currentMax 为当前元素与当前元素加上 currentMax 的较大值。
  3. 每次更新 currentMax 时，将其与 globalMax 比较，更新 globalMax 为两者的较大值。
  4. 最终，globalMax 就是数组中最大的子数组和。

以下是Kadane算法的Java实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class KadaneAlgorithm {
    public static int maxSubArray(int[] nums) {
        if (nums == null || nums.length == 0) {
            throw new IllegalArgumentException("Input array is invalid.");
        }

        int currentMax = nums[0];
        int globalMax = nums[0];

        for (int i = 1; i < nums.length; i++) {
            currentMax = Math.max(nums[i], currentMax + nums[i]);
            globalMax = Math.max(globalMax, currentMax);
        }

        return globalMax;
    }

    public static void main(String[] args) {
        // Test case 1
        int[] nums1 = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        System.out.println("Test case 1: " + maxSubArray(nums1)); // Output: 6

        // Test case 2
        int[] nums2 = {1};
        System.out.println("Test case 2: " + maxSubArray(nums2)); // Output: 1

        // Test case 3
        int[] nums3 = {5, 4, -1, 7, 8};
        System.out.println("Test case 3: " + maxSubArray(nums3)); // Output: 23
    }
}

算法复杂度:

  • 时间复杂度：O(n)，其中 n 是数组的长度。
  • 空间复杂度：O(1)，算法只使用了常数个额外的变量。

53. 最大子数组和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

        子数组 是数组中的一个连续部分。

        示例 1：

        输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
        输出：6
        解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
        示例 2：

        输入：nums = [1]
        输出：1
        示例 3：

        输入：nums = [5,4,-1,7,8]
        输出：23

        提示：

        1 <= nums.length <= 105
        -104 <= nums[i] <= 104

        进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。*/
public class MaximumSubarray53 {
    public int maxSubArray(int[] nums) {
        int currentMax = nums[0];
        int globalMax = nums[0];

        for (int i = 1; i < nums.length; i++) {
            currentMax = Math.max(nums[i], currentMax + nums[i]);
            globalMax = Math.max(globalMax, currentMax);
        }

        return globalMax;
    }

    public static void main(String[] args) {
        MaximumSubarray53 solution = new MaximumSubarray53();
        int[] nums = {-2,1,-3,4,-1,2,1,-5,4};
        System.out.println(solution.maxSubArray(nums));
        int[] nums1 = {1};
        System.out.println(solution.maxSubArray(nums1));
        int[] nums2 = {5,4,-1,7,8};
        System.out.println(solution.maxSubArray(nums2));
    }
}

918. 环形子数组的最大和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/*给定一个长度为 n 的环形整数数组 nums ，返回 nums 的非空 子数组 的最大可能和 。

        环形数组 意味着数组的末端将会与开头相连呈环状。形式上， nums[i] 的下一个元素是 nums[(i + 1) % n] ， nums[i] 的前一个元素是 nums[(i - 1 + n) % n] 。

        子数组 最多只能包含固定缓冲区 nums 中的每个元素一次。形式上，对于子数组 nums[i], nums[i + 1], ..., nums[j] ，不存在 i <= k1, k2 <= j 其中 k1 % n == k2 % n 。

        示例 1：

        输入：nums = [1,-2,3,-2]
        输出：3
        解释：从子数组 [3] 得到最大和 3
        示例 2：

        输入：nums = [5,-3,5]
        输出：10
        解释：从子数组 [5,5] 得到最大和 5 + 5 = 10
        示例 3：

        输入：nums = [3,-2,2,-3]
        输出：3
        解释：从子数组 [3] 和 [3,-2,2] 都可以得到最大和 3


        提示：

        n == nums.length
        1 <= n <= 3 * 104
        -3 * 104 <= nums[i] <= 3 * 104*/
public class MaximumSumCircularSubarray918 {
    public int maxSubarraySumCircular(int[] nums) {
        int totalSum = 0;
        int maxSum = nums[0];
        int currentMax = 0;
        int minSum = nums[0];
        int currentMin = 0;

        // 分别获取总和、最大子数组和、最小子数组和
        for (int num : nums) {
            totalSum += num;

            currentMax = Math.max(currentMax + num, num);
            maxSum = Math.max(maxSum, currentMax);

            currentMin = Math.min(currentMin + num, num);
            minSum = Math.min(minSum, currentMin);
        }

        // 当最大子数组和大于0时，取最大子数组和、总和-最小子数组和二者最大的值为实际上的最大和
        if (maxSum > 0) {
            return Math.max(maxSum, totalSum - minSum);
        }

        // 当最大子数组和小于0时，数组中不包含大于等于 0 的元素
        return maxSum;
    }

    public static void main(String[] args) {
        MaximumSumCircularSubarray918 solution = new MaximumSumCircularSubarray918();
        int[] nums = {1,-2,3,-2};
        System.out.println(solution.maxSubarraySumCircular(nums));
        int[] nums1 = {5,-3,5};
        System.out.println(solution.maxSubarraySumCircular(nums1));
        int[] nums2 = {3,-2,2,-3};
        System.out.println(solution.maxSubarraySumCircular(nums2));
    }
}

二分查找：通过比较目标值与数组中间元素的大小关系，从而将搜索范围缩小一半。如果目标值等于中间元素，搜索成功。如果目标值小于中间元素，说明目标值可能在数组的左半部分，可以将搜索范围缩小到左半部分。如果目标值大于中间元素，说明目标值可能在数组的右半部分，可以将搜索范围缩小到右半部分。重复这个过程，直到找到目标值或者搜索范围为空。

基本步骤：

  1. 初始化左右两个指针，分别指向数组的第一个元素和最后一个元素。
  2. 计算中间元素的索引。
  3. 比较中间元素与目标值的大小。
    • 如果中间元素等于目标值，返回中间元素的索引。
    • 如果中间元素小于目标值，说明目标值可能在右半部分，将左指针移动到中间元素的右侧一位。
    • 如果中间元素大于目标值，说明目标值可能在左半部分，将右指针移动到中间元素的左侧一位。
  4. 重复步骤2到步骤3，直到左指针大于右指针，说明搜索范围为空，返回 -1 表示未找到目标值。

时间复杂度是 O(log n)，其中 n 是数组的长度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class BinarySearch {
    public static int binarySearch(int[] nums, int target) {
        int left = 0;
        int 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; // 搜索范围为空，未找到目标值
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int target = 6;

        int result = binarySearch(nums, target);

        if (result != -1) {
            System.out.println("目标值 " + target + " 在数组中的索引为 " + result);
        } else {
            System.out.println("目标值 " + target + " 不在数组中");
        }
    }
}

35. 搜索插入位置 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

        请必须使用时间复杂度为 O(log n) 的算法。

        示例 1:

        输入: nums = [1,3,5,6], target = 5
        输出: 2
        示例 2:

        输入: nums = [1,3,5,6], target = 2
        输出: 1
        示例 3:

        输入: nums = [1,3,5,6], target = 7
        输出: 4

        提示:

        1 <= nums.length <= 104
        -104 <= nums[i] <= 104
        nums 为 无重复元素 的 升序 排列数组
        -104 <= target <= 104*/
public class SearchInsertPosition35 {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int 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 left;
    }

    public static void main(String[] args) {
        SearchInsertPosition35 solution = new SearchInsertPosition35();
        int[] nums = {1,3,5,6};
        System.out.println(solution.searchInsert(nums, 5));
        System.out.println(solution.searchInsert(nums, 2));
        System.out.println(solution.searchInsert(nums, 7));
    }
}

74. 搜索二维矩阵 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/*给你一个满足下述两条属性的 m x n 整数矩阵：

        每行中的整数从左到右按非严格递增顺序排列。
        每行的第一个整数大于前一行的最后一个整数。
        给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。

        示例 1：

        输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
        输出：true
        示例 2：

        输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
        输出：false

        提示：

        m == matrix.length
        n == matrix[i].length
        1 <= m, n <= 100
        -104 <= matrix[i][j], target <= 104*/
public class SearchA2dMatrix74 {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }

        int rows = matrix.length;
        int cols = matrix[0].length;

        // 二维矩阵的第一个和最后一个元素
        int left = 0, right = rows * cols - 1;

        // 将矩阵按行展开成一个有序数组，通过二分查找找到目标值
        while (left <= right) {
            int mid = left + (right - left) / 2;
            // mid为中间值，但要换算为二维坐标，mid/cols获得在第几行，求余可得在第几列
            int midValue = matrix[mid / cols][mid % cols];

            if (midValue == target) {
                return true;
            } else if (midValue < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return false;
    }

    public static void main(String[] args) {
        // 二分查找的时间复杂度为 O(log(m * n))，其中 m 为矩阵的行数，n 为矩阵的列数
        // 使用了常数级的额外空间，空间复杂度为 O(1)
        SearchA2dMatrix74 solution = new SearchA2dMatrix74();

        int[][] matrix1 = {
                {1, 3, 5, 7},
                {10, 11, 16, 20},
                {23, 30, 34, 60}
        };
        int target1 = 3;
        System.out.println(solution.searchMatrix(matrix1, target1)); // Output: true

        int[][] matrix2 = {
                {1, 3, 5, 7},
                {10, 11, 16, 20},
                {23, 30, 34, 60}
        };
        int target2 = 13;
        System.out.println(solution.searchMatrix(matrix2, target2)); // Output: false
    }
}

162. 寻找峰值 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/*峰值元素是指其值严格大于左右相邻值的元素。

        给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

        你可以假设 nums[-1] = nums[n] = -∞ 。

        你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

        示例 1：

        输入：nums = [1,2,3,1]
        输出：2
        解释：3 是峰值元素，你的函数应该返回其索引 2。
        示例 2：

        输入：nums = [1,2,1,3,5,6,4]
        输出：1 或 5
        解释：你的函数可以返回索引 1，其峰值元素为 2；
        或者返回索引 5， 其峰值元素为 6。

        提示：

        1 <= nums.length <= 1000
        -231 <= nums[i] <= 231 - 1
        对于所有有效的 i 都有 nums[i] != nums[i + 1]*/
public class FindPeakElement162 {
    public int findPeakElement(int[] nums) {
        int left = 0, right = nums.length - 1;

        while (left < right) {
            int mid = left + (right - left) / 2;

            // 比较中间元素和右侧相邻元素大小，小于表示峰值在右侧，否则在左侧，最终left回指向一个峰值
            if (nums[mid] < nums[mid + 1]) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }

        return left;
    }

    public static void main(String[] args) {
        // O(log n)
        FindPeakElement162 solution = new FindPeakElement162();

        // Test case 1
        int[] nums1 = {1, 2, 3, 1};
        int result1 = solution.findPeakElement(nums1);
        System.out.println("Peak element index for nums1: " + result1);

        // Test case 2
        int[] nums2 = {1, 2, 1, 3, 5, 6, 4};
        int result2 = solution.findPeakElement(nums2);
        System.out.println("Peak element index for nums2: " + result2);
    }
}

33. 搜索旋转排序数组 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*整数数组 nums 按升序排列，数组中的值 互不相同 。

        在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

        给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

        你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

        示例 1：

        输入：nums = [4,5,6,7,0,1,2], target = 0
        输出：4
        示例 2：

        输入：nums = [4,5,6,7,0,1,2], target = 3
        输出：-1
        示例 3：

        输入：nums = [1], target = 0
        输出：-1

        提示：

        1 <= nums.length <= 5000
        -104 <= nums[i] <= 104
        nums 中的每个值都 独一无二
        题目数据保证 nums 在预先未知的某个下标上进行了旋转
        -104 <= target <= 104*/
public class SearchInRotatedSortedArray33 {
    public int search(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 (nums[left] <= nums[mid]) {
                // 左半部分有序
                if (nums[left] <= target && target < nums[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                // 右半部分有序
                if (nums[mid] < target && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        SearchInRotatedSortedArray33 solution = new SearchInRotatedSortedArray33();

        // Test case 1
        int[] nums1 = {4, 5, 6, 7, 0, 1, 2};
        int target1 = 0;
        int result1 = solution.search(nums1, target1);
        System.out.println("Index of target1: " + result1);

        // Test case 2
        int[] nums2 = {4, 5, 6, 7, 0, 1, 2};
        int target2 = 3;
        int result2 = solution.search(nums2, target2);
        System.out.println("Index of target2: " + result2);

        // Test case 3
        int[] nums3 = {1};
        int target3 = 0;
        int result3 = solution.search(nums3, target3);
        System.out.println("Index of target3: " + result3);
    }
}

34. 在排序数组中查找元素的第一个和最后一个位置 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/*给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

        如果数组中不存在目标值 target，返回 [-1, -1]。

        你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

        示例 1：

        输入：nums = [5,7,7,8,8,10], target = 8
        输出：[3,4]
        示例 2：

        输入：nums = [5,7,7,8,8,10], target = 6
        输出：[-1,-1]
        示例 3：

        输入：nums = [], target = 0
        输出：[-1,-1]

        提示：

        0 <= nums.length <= 105
        -109 <= nums[i] <= 109
        nums 是一个非递减数组
        -109 <= target <= 109*/
public class FindFirstAndLastPositionOfElementInSortedArray34 {
    public int[] searchRange(int[] nums, int target) {
        // 使用两次二分查找，分别找到目标值的第一次出现位置和最后一次出现位置
        int firstOccurrence = findFirstOccurrence(nums, target);
        int lastOccurrence = findLastOccurrence(nums, target);

        return new int[]{firstOccurrence, lastOccurrence};
    }

    private int findFirstOccurrence(int[] nums, int target) {
        int first = -1;
        int left = 0, right = nums.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] >= target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }

            if (nums[mid] == target) {
                first = mid;
            }
        }

        return first;
    }

    private int findLastOccurrence(int[] nums, int target) {
        int last = -1;
        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 (nums[mid] == target) {
                last = mid;
            }
        }

        return last;
    }

    public static void main(String[] args) {
        FindFirstAndLastPositionOfElementInSortedArray34 solution = new FindFirstAndLastPositionOfElementInSortedArray34();

        // Test case 1
        int[] nums1 = {5,7,7,8,8,10};
        int target1 = 8;
        int[] result1 = solution.searchRange(nums1, target1);
        printList(result1);

        // Test case 2
        int[] nums2 = {5,7,7,8,8,10};
        int target2 = 6;
        int[] result2 = solution.searchRange(nums2, target2);
        printList(result2);

        // Test case 3
        int[] nums3 = {};
        int target3 = 0;
        int[] result3 = solution.searchRange(nums3, target3);
        printList(result3);

        int[] nums4 = {1};
        int target4 = 1;
        int[] result4 = solution.searchRange(nums4, target4);
        printList(result4);

        int[] nums5 = {5,7,7,8,8,10};
        int target5 = 10;
        int[] result5 = solution.searchRange(nums5, target5);
        printList(result5);

        int[] nums6 = {3,3,3};
        int target6 = 3;
        int[] result6 = solution.searchRange(nums6, target6);
        printList(result6);
    }

    private static void printList(int[] result) {
        for (int i : result) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

153. 寻找旋转排序数组中的最小值 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/*已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
        若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
        若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
        注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

        给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

        你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

        示例 1：

        输入：nums = [3,4,5,1,2]
        输出：1
        解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
        示例 2：

        输入：nums = [4,5,6,7,0,1,2]
        输出：0
        解释：原数组为 [0,1,2,4,5,6,7] ，旋转 3 次得到输入数组。
        示例 3：

        输入：nums = [11,13,15,17]
        输出：11
        解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

        提示：

        n == nums.length
        1 <= n <= 5000
        -5000 <= nums[i] <= 5000
        nums 中的所有整数 互不相同
        nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转*/
public class FindMinimumInRotatedSortedArray153 {
    public int findMin(int[] nums) {
        int left = 0, right = nums.length - 1;
        int min = Integer.MAX_VALUE;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[left] <= nums[mid]) {
                // 左边有序，区间最小值为最左边
                min = Math.min(min, nums[left]);
                left = mid + 1;
            } else {
                // 左边无序，最小值为区间中间的某个值
                min = Math.min(min, nums[mid]);
                right = mid - 1;
            }
        }

        return min;
    }

    public static void main(String[] args) {
        FindMinimumInRotatedSortedArray153 solution = new FindMinimumInRotatedSortedArray153();

        // Test case 1
        int[] nums1 = {3,4,5,1,2};
        System.out.println(solution.findMin(nums1));

        // Test case 2
        int[] nums2 = {4,5,6,7,0,1,2};
        System.out.println(solution.findMin(nums2));

        // Test case 3
        int[] nums3 = {11,13,15,17};
        System.out.println(solution.findMin(nums3));
    }
}

4. 寻找两个正序数组的中位数 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/*给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

        算法的时间复杂度应该为 O(log (m+n)) 。

        示例 1：

        输入：nums1 = [1,3], nums2 = [2]
        输出：2.00000
        解释：合并数组 = [1,2,3] ，中位数 2
        示例 2：

        输入：nums1 = [1,2], nums2 = [3,4]
        输出：2.50000
        解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

        提示：

        nums1.length == m
        nums2.length == n
        0 <= m <= 1000
        0 <= n <= 1000
        1 <= m + n <= 2000
        -106 <= nums1[i], nums2[i] <= 106*/
public class MedianOfTwoSortedArrays4 {

    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int totalLength = nums1.length + nums2.length;

        if (totalLength % 2 == 0) {
            // 对于总长度为偶数的情况，中位数即为第 (totalLength / 2) 和第 (totalLength / 2 + 1) 小的元素的平均值。
            int leftMedian = findKthElement(nums1, nums2, totalLength / 2);
            int rightMedian = findKthElement(nums1, nums2, totalLength / 2 + 1);
            return (leftMedian + rightMedian) / 2.0;
        } else {
            // 对于总长度为奇数的情况，中位数即为第 (totalLength / 2 + 1) 小的元素
            return findKthElement(nums1, nums2, totalLength / 2 + 1);
        }
    }

    private int findKthElement(int[] nums1, int[] nums2, int k) {
        // 找到第K位元素
        int index1 = 0, index2 = 0;

        while (true) {
            // 如果某一数组遍历完毕，那k元素一定在另一数组
            if (index1 == nums1.length) {
                return nums2[index2 + k - 1];
            }
            if (index2 == nums2.length) {
                return nums1[index1 + k - 1];
            }
            // 返回两数组的最小值
            if (k == 1) {
                return Math.min(nums1[index1], nums2[index2]);
            }

            // 将k分半，分别在两数组中查找
            int half = k / 2;
            int newIndex1 = Math.min(index1 + half, nums1.length) - 1;
            int newIndex2 = Math.min(index2 + half, nums2.length) - 1;

            if (nums1[newIndex1] <= nums2[newIndex2]) {
                // 数组1中间元素小于数组2，说明k元素一定在数组1的后半和数组2的前半，分别更新索引和最新的k值
                k -= (newIndex1 - index1 + 1);
                index1 = newIndex1 + 1;
            } else {
                // 同理
                k -= (newIndex2 - index2 + 1);
                index2 = newIndex2 + 1;
            }
        }
    }

    public static void main(String[] args) {
        MedianOfTwoSortedArrays4 solution = new MedianOfTwoSortedArrays4();

        // Test case 1
        int[] nums1 = {1, 3};
        int[] nums2 = {2};
        double result1 = solution.findMedianSortedArrays(nums1, nums2);
        System.out.println("Result for test case 1: " + result1);

        // Test case 2
        int[] nums3 = {1, 2};
        int[] nums4 = {3, 4};
        double result2 = solution.findMedianSortedArrays(nums3, nums4);
        System.out.println("Result for test case 2: " + result2);
    }
}

3.19 堆 Heap

堆（Heap）是一种特殊的数据结构，它通常是一个完全二叉树。根据节点值之间的关系，堆分为最大堆和最小堆。

  • 最大堆（Max Heap）： 在最大堆中，每个节点的值都大于或等于其子节点的值。堆顶元素是整个堆中的最大值。
  • 最小堆（Min Heap）： 在最小堆中，每个节点的值都小于或等于其子节点的值。堆顶元素是整个堆中的最小值。

堆的操作包括插入元素、删除元素、以及获取堆顶元素。

  • 插入元素时，可以先将元素添加到堆的末尾，然后通过“上浮”（percolate up）的方式，将元素移到合适的位置，以保持堆的性质。
  • 删除元素时，可以将堆顶元素与堆的最后一个元素交换，然后通过“下沉”（percolate down）的方式，将新的堆顶元素移到合适的位置。

堆的应用。

  • 最大堆常常用于实现优先队列，优先队列是一种可以按照优先级取出元素的队列，而堆可以高效地实现这种数据结构。
  • 最小堆用于实现一些特定场景的算法，比如 Dijkstra 算法等。

在 Java 中，堆可以通过 PriorityQueue 类来实现。PriorityQueue 默认是最小堆，如果需要实现最大堆，可以通过传递一个比较器（Comparator）来实现。

215. 数组中的第K个最大元素 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

        请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

        你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

        示例 1:

        输入: [3,2,1,5,6,4], k = 2
        输出: 5
        示例 2:

        输入: [3,2,3,1,2,4,5,5,6], k = 4
        输出: 4

        提示：

        1 <= k <= nums.length <= 105
        -104 <= nums[i] <= 104*/
public class KthLargestElementInAnArray215 {

    public int findKthLargest(int[] nums, int k) {
        // 使用最小堆来维护前 k 个最大的元素，小值会优先移除，最终堆保留前K大的元素，堆顶为最小元素
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();

        for (int num : nums) {
            minHeap.offer(num);

            // 如果堆的大小超过 k，移除堆顶元素，保持堆的大小为 k
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }

        // 堆顶元素即为第 k 个最大的元素
        return minHeap.peek();
    }

    public static void main(String[] args) {
        KthLargestElementInAnArray215 solution = new KthLargestElementInAnArray215();

        // 示例 1
        int[] nums1 = {3, 2, 1, 5, 6, 4};
        int k1 = 2;
        System.out.println(solution.findKthLargest(nums1, k1)); // 输出: 5

        // 示例 2
        int[] nums2 = {3, 2, 3, 1, 2, 4, 5, 5, 6};
        int k2 = 4;
        System.out.println(solution.findKthLargest(nums2, k2)); // 输出: 4
    }
}

502. IPO <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/*假设 力扣（LeetCode）即将开始 IPO 。为了以更高的价格将股票卖给风险投资公司，力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多 k 个不同的项目。帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。

        给你 n 个项目。对于每个项目 i ，它都有一个纯利润 profits[i] ，和启动该项目需要的最小资本 capital[i] 。

        最初，你的资本为 w 。当你完成一个项目时，你将获得纯利润，且利润将被添加到你的总资本中。

        总而言之，从给定项目中选择 最多 k 个不同项目的列表，以 最大化最终资本 ，并输出最终可获得的最多资本。

        答案保证在 32 位有符号整数范围内。

        示例 1：

        输入：k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]
        输出：4
        解释：
        由于你的初始资本为 0，你仅可以从 0 号项目开始。
        在完成后，你将获得 1 的利润，你的总资本将变为 1。
        此时你可以选择开始 1 号或 2 号项目。
        由于你最多可以选择两个项目，所以你需要完成 2 号项目以获得最大的资本。
        因此，输出最后最大化的资本，为 0 + 1 + 3 = 4。
        示例 2：

        输入：k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]
        输出：6

        提示：

        1 <= k <= 105
        0 <= w <= 109
        n == profits.length
        n == capital.length
        1 <= n <= 105
        0 <= profits[i] <= 104
        0 <= capital[i] <= 109*/
public class Ipo502 {

    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
        int n = profits.length;

        // 创建一个最小堆，按照 capital 的升序排序
        PriorityQueue<int[]> minCapitalHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));

        // 创建一个最大堆，按照 profits 的降序排序
        PriorityQueue<int[]> maxProfitHeap = new PriorityQueue<>((a, b) -> b[1] - a[1]);

        // 将项目按照 capital 分别加入最小堆和最大堆
        for (int i = 0; i < n; i++) {
            minCapitalHeap.offer(new int[]{capital[i], profits[i]});
        }

        // 选取最多 k 个项目
        for (int i = 0; i < k; i++) {
            // 将所有符合资本要求的项目加入最大堆
            while (!minCapitalHeap.isEmpty() && minCapitalHeap.peek()[0] <= w) {
                maxProfitHeap.offer(minCapitalHeap.poll());
            }

            // 如果最大堆为空，说明没有项目可做，直接返回当前资本
            if (maxProfitHeap.isEmpty()) {
                return w;
            }

            // 选择利润最大的项目，更新资本
            w += maxProfitHeap.poll()[1];
        }

        return w;
    }

    public static void main(String[] args) {
        // 最小堆和最大堆的插入和删除操作的时间复杂度为 O(log n)，整体时间复杂度为 O(n log n)，其中 n 是项目的数量。
        // 使用了两个堆来存储项目，堆的大小最大为 n，因此空间复杂度为 O(n)。
        Ipo502 solution = new Ipo502();

        // 测试用例1
        int k1 = 2;
        int w1 = 0;
        int[] profits1 = {1, 2, 3};
        int[] capital1 = {0, 1, 1};
        System.out.println(solution.findMaximizedCapital(k1, w1, profits1, capital1)); // Output: 4

        // 测试用例2
        int k2 = 3;
        int w2 = 0;
        int[] profits2 = {1, 2, 3};
        int[] capital2 = {0, 1, 2};
        System.out.println(solution.findMaximizedCapital(k2, w2, profits2, capital2)); // Output: 6
    }
}

373. 查找和最小的 K 对数字 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/*给定两个以 非递减顺序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k 。

        定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。

        请找到和最小的 k 个数对 (u1,v1),  (u2,v2)  ...  (uk,vk) 。

        示例 1:

        输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
        输出: [1,2],[1,4],[1,6]
        解释: 返回序列中的前 3 对数：
        [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
        示例 2:

        输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2
        输出: [1,1],[1,1]
        解释: 返回序列中的前 2 对数：
        [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
        示例 3:

        输入: nums1 = [1,2], nums2 = [3], k = 3
        输出: [1,3],[2,3]
        解释: 也可能序列中所有的数对都被返回:[1,3],[2,3]


        提示:

        1 <= nums1.length, nums2.length <= 105
        -109 <= nums1[i], nums2[i] <= 109
        nums1 和 nums2 均为 升序排列
        1 <= k <= 104
        k <= nums1.length * nums2.length*/
public class FindKPairsWithSmallestSums373 {
    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        List<List<Integer>> result = new ArrayList<>();

        if (nums1.length == 0 || nums2.length == 0 || k == 0) {
            return result;
        }

        // 创建一个最小堆，按照和的升序排序
        PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0] + a[1]));

        // 初始化最小堆，将所有 nums1 和 nums2 的组合加入堆
        for (int i = 0; i < Math.min(nums1.length, k); i++) {
            minHeap.offer(new int[]{nums1[i], nums2[0], 0});
        }

        // 取出最小堆中的元素，直到满足 k 个
        while (k > 0 && !minHeap.isEmpty()) {
            int[] pair = minHeap.poll();
            int i = pair[2];

            // 将当前最小和的组合添加到结果列表
            List<Integer> currentPair = new ArrayList<>();
            currentPair.add(pair[0]);
            currentPair.add(pair[1]);
            result.add(currentPair);

            // 将 nums2 中和当前 nums1[i] 对应的下一个数加入最小堆
            if (i + 1 < nums2.length) {
                minHeap.offer(new int[]{pair[0], nums2[i + 1], i + 1});
            }

            k--;
        }

        return result;
    }

    public static void main(String[] args) {
        FindKPairsWithSmallestSums373 solution = new FindKPairsWithSmallestSums373();

        // 测试用例1
        int[] nums11 = {1, 7, 11};
        int[] nums21 = {2, 4, 6};
        int k1 = 3;
        System.out.println(solution.kSmallestPairs(nums11, nums21, k1)); // Output: [[1,2],[1,4],[1,6]]

        // 测试用例2
        int[] nums12 = {1, 1, 2};
        int[] nums22 = {1, 2, 3};
        int k2 = 2;
        System.out.println(solution.kSmallestPairs(nums12, nums22, k2)); // Output: [[1,1],[1,1]]

        // 测试用例3
        int[] nums13 = {1, 2};
        int[] nums23 = {3};
        int k3 = 3;
        System.out.println(solution.kSmallestPairs(nums13, nums23, k3)); // Output: [[1,3],[2,3]]
    }
}

295. 数据流的中位数 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/*中位数是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。

        例如 arr = [2,3,4] 的中位数是 3 。
        例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。
        实现 MedianFinder 类:

        MedianFinder() 初始化 MedianFinder 对象。

        void addNum(int num) 将数据流中的整数 num 添加到数据结构中。

        double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

        示例 1：

        输入
        ["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
        [[], [1], [2], [], [3], []]
        输出
        [null, null, null, 1.5, null, 2.0]

        解释
        MedianFinder medianFinder = new MedianFinder();
        medianFinder.addNum(1);    // arr = [1]
        medianFinder.addNum(2);    // arr = [1, 2]
        medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
        medianFinder.addNum(3);    // arr[1, 2, 3]
        medianFinder.findMedian(); // return 2.0
        提示:

        -105 <= num <= 105
        在调用 findMedian 之前，数据结构中至少有一个元素
        最多 5 * 104 次调用 addNum 和 findMedian*/
public class FindMedianFromDataStream295 {
    PriorityQueue<Integer> minHeap; // 小顶堆，存放较大的一半元素
    PriorityQueue<Integer> maxHeap; // 大顶堆，存放较小的一半元素

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

    public void addNum(int num) {
        if (maxHeap.isEmpty() || num <= maxHeap.peek()) {
            // 如果当前元素小于等于大顶堆的堆顶元素，将其加入大顶堆
            maxHeap.offer(num);
        } else {
            minHeap.offer(num);
        }

        // 调整堆的大小，使得两个堆的大小之差不超过1
        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 static void main(String[] args) {
        // O(log N)
        FindMedianFromDataStream295 medianFinder = new FindMedianFromDataStream295();
        medianFinder.addNum(1);
        medianFinder.addNum(2);
        System.out.println(medianFinder.findMedian()); // Output: 1.5
        medianFinder.addNum(3);
        System.out.println(medianFinder.findMedian()); // Output: 2.0
    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

3.20 位运算 Bit Manipulation

Java中的二进制是有符号整数类型

  • 二进制的表示：

    1. 二进制字面量： 在Java 7及更高版本中，可以使用前缀0b或0B表示二进制数。

      1
      int binaryNumber = 0b101010; // 表示42

    2. Integer.toBinaryString方法： 可以使用Integer.toBinaryString方法将整数转换为二进制字符串。

      1
      2
      javaCopy codeint decimalNumber = 42;
      String binaryString = Integer.toBinaryString(decimalNumber); // 得到"101

  • 有符号整数使用补码表示，其中最高位（最左边的位）是符号位，0表示正数，1表示负数。

  • Java中并没有直接支持无符号整数的原生数据类型。所有整数类型都是有符号的。

  • 在Java中，如果要处理无符号整数，通常会使用更大的数据类型（如long）来容纳更大范围的正数。

Java中的位运算操作符：

  • 按位与 &：两个对应位都为 1 时，结果为 1；否则，结果为 0。

    1
    2
    3
    int a = 5;   // 二进制表示为 0101
    int b = 3;   // 二进制表示为 0011
    int result = a & b;  // 结果为 0001，即 1

  • 按位或 | ：两个对应位有一个为 1 时，结果为 1；否则，结果为 0。

    1
    2
    3
    int a = 5;   // 二进制表示为 0101
    int b = 3;   // 二进制表示为 0011
    int result = a | b;  // 结果为 0111，即 7

  • 按位异或 ^ ：两个对应位相异时，结果为 1；否则，结果为 0。

    1
    2
    3
    int a = 5;   // 二进制表示为 0101
    int b = 3;   // 二进制表示为 0011
    int result = a ^ b;  // 结果为 0110，即 6

  • 取反 ~ ：对操作数的每一位取反，即 0 变为 1，1 变为 0。

    1
    2
    int a = 5;   // 二进制表示为 0101
    int result = ~a;  // 结果为 1010，即 -6（取反后再加1）

  • 左移 << ：将操作数的二进制表示向左移动指定的位数，右侧空出的位用 0 填充。

    1
    2
    int a = 5;   // 二进制表示为 0101
    int result = a << 2;  // 结果为 010100（左移两位），即 20

  • 右移 >> ：将操作数的二进制表示向右移动指定的位数，左侧空出的位用符号位（正数为 0，负数为 1）填充。

    1
    2
    int a = 5;   // 二进制表示为 0101
    int result = a >> 1;  // 结果为 0010（右移一位），即 2

  • 无符号右移 >>> ：将操作数的二进制表示向右移动指定的位数，左侧空出的位用 0 填充。

    1
    2
    int a = -5;  // 二进制表示为 11111111111111111111111111111011
    int result = a >>> 1;  // 结果为 01111111111111111111111111111101，即 2147483645

67. 二进制求和 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

        示例 1：

        输入:a = "11", b = "1"
        输出："100"
        示例 2：

        输入：a = "1010", b = "1011"
        输出："10101"

        提示：

        1 <= a.length, b.length <= 104
        a 和 b 仅由字符 '0' 或 '1' 组成
        字符串如果不是 "0" ，就不含前导零*/
public class AddBinary67 {
    public static String addBinary(String a, String b) {
        // 解法1.模拟二进制加法 O(max{a, b})
        StringBuilder result = new StringBuilder();
        int carry = 0;

        int i = a.length() - 1;
        int j = b.length() - 1;

        while (i >= 0 || j >= 0 || carry > 0) {
            // 获取当前位的数字，如果超出字符串长度，用0代替
            int digitA = (i >= 0) ? Character.getNumericValue(a.charAt(i--)) : 0;
            int digitB = (j >= 0) ? Character.getNumericValue(b.charAt(j--)) : 0;

            // 计算当前位的和
            int sum = digitA + digitB + carry;
            // 将和的最低位插入到结果字符串的最前面
            result.insert(0, sum % 2);
            // 更新进位
            carry = sum / 2;
        }

        return result.toString();
    }

    public static void main(String[] args) {
        String binaryA = "11";
        String binaryB = "1";
        String sum = addBinary(binaryA, binaryB);

        System.out.println("Binary A: " + binaryA);
        System.out.println("Binary B: " + binaryB);
        System.out.println("Sum: " + sum);

        binaryA = "1010";
        binaryB = "1011";
        sum = addBinary(binaryA, binaryB);

        System.out.println("Binary A: " + binaryA);
        System.out.println("Binary B: " + binaryB);
        System.out.println("Sum: " + sum);

    }
}

190. 颠倒二进制位 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*颠倒给定的 32 位无符号整数的二进制位。

        提示：

        请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
        在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。

        示例 1：

        输入：n = 00000010100101000001111010011100
        输出：964176192 (00111001011110000010100101000000)
        解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
        因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
        示例 2：

        输入：n = 11111111111111111111111111111101
        输出：3221225471 (10111111111111111111111111111111)
        解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
        因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。

        提示：

        输入是一个长度为 32 的二进制字符串

        进阶: 如果多次调用这个函数，你将如何优化你的算法？*/
public class ReverseBits190 {

    // M1用于将相邻的两位交换
    private static final int M1 = 0x55555555; // 01010101010101010101010101010101
    // M2用于将相邻的四位交换
    private static final int M2 = 0x33333333; // 00110011001100110011001100110011
    // M4用于将相邻的八位交换
    private static final int M4 = 0x0f0f0f0f; // 00001111000011110000111100001111
    // M4用于将相邻的十六位交换
    private static final int M8 = 0x00ff00ff; // 00000000111111110000000011111111

    public int reverseBits(int n) {
        // 解法1.转二进制字符串，再反转字符串，再转为整数 O(log₂n)
        //// 补零确保32位，不足则会填充空格，然后替换为0
        //String binaryString = String.format("%32s", Integer.toBinaryString(n)).replace(' ', '0');
        //StringBuilder sb = new StringBuilder();
        //
        //// 反转字符串
        //for (int i = binaryString.length() - 1; i >= 0; i--) {
        //    sb.append(binaryString.charAt(i));
        //}
        //
        //// 用更大的long来进行转换
        //return Long.valueOf(sb.toString(), 2).intValue();

        // 解法2.逐位颠倒 O(logn)
        //int rev = 0;
        //for (int i = 0; i < 32 && n != 0; ++i) {
        //    // n & 1获取n的最低位，<< (31 - i)将当前位放置到反转的位置，即左移31-i位，通过|=按位或加到rev中
        //    rev |= (n & 1) << (31 - i);
        //    // 将n逻辑右移1位，去掉已经处理过的最低位
        //    n >>>= 1;
        //    //System.out.println(i + "rev=" + Integer.toBinaryString(rev));
        //    //System.out.println(i + "n=" + Integer.toBinaryString(n));
        //}
        //return rev;

        // 解法3.位运算分治 O(1)
        // 将相邻数字互换：将n逻辑右移1位与M1进行按位与操作，使奇数位的数字清零；n直接与M1进行按位与操作后再左移1位，使奇数位的数字移动到偶数位；通过按位或实现奇偶数字互换
        n = n >>> 1 & M1 | (n & M1) << 1;
        System.out.println(String.format("%32s", Integer.toBinaryString(n)).replace(' ', '0'));
        // 将每两位数字互换
        n = n >>> 2 & M2 | (n & M2) << 2;
        System.out.println(String.format("%32s", Integer.toBinaryString(n)).replace(' ', '0'));
        // 将每四位数字互换
        n = n >>> 4 & M4 | (n & M4) << 4;
        System.out.println(String.format("%32s", Integer.toBinaryString(n)).replace(' ', '0'));
        // 将每八位数字互换
        n = n >>> 8 & M8 | (n & M8) << 8;
        System.out.println(String.format("%32s", Integer.toBinaryString(n)).replace(' ', '0'));
        // 将整个32位数字颠倒
        return n >>> 16 | n << 16;
    }

    public static void main(String[] args) {
        ReverseBits190 solution = new ReverseBits190();
        int result = solution.reverseBits(0b00000010100101000001111010011100);
        System.out.println(result);
        System.out.println(solution.reverseBits(0b11111111111111111111111111111101));
    }
}

191. 位1的个数 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/*编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。

        提示：

        请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
        在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在 示例 3 中，输入表示有符号整数 -3。

        示例 1：

        输入：n = 00000000000000000000000000001011
        输出：3
        解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
        示例 2：

        输入：n = 00000000000000000000000010000000
        输出：1
        解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
        示例 3：

        输入：n = 11111111111111111111111111111101
        输出：31
        解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

        提示：

        输入必须是长度为 32 的 二进制串 。

        进阶：

        如果多次调用这个函数，你将如何优化你的算法？*/
public class NumberOf1Bits191 {
    public int hammingWeight(int n) {
        // 解法1.转字符串
        //String binaryString = String.format("%32s", Integer.toBinaryString(n)).replace(" ", "0");
        //int count = 0;
        //for (int i = 0;i < binaryString.length();i++) {
        //    char e = binaryString.charAt(i);
        //    if ('1' == e) {
        //        count++;
        //    }
        //}
        //return count;

        // 解法2. Brian Kernighan 算法，通过n &= (n - 1)消除n最左侧的1，直到n等于0； O(k)，k为1的个数
        int count = 0;
        while (n != 0) {
            n &= (n - 1);
            count++;
        }
        return count;
    }

    public static void main(String[] args) {
        NumberOf1Bits191 solution = new NumberOf1Bits191();
        System.out.println(solution.hammingWeight(0b00000000000000000000000000001011));
        System.out.println(solution.hammingWeight(0b00000000000000000000000010000000));
        System.out.println(solution.hammingWeight(0b11111111111111111111111111111101));
    }
}

136. 只出现一次的数字 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

        你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

        示例 1 ：

        输入：nums = [2,2,1]
        输出：1
        示例 2 ：

        输入：nums = [4,1,2,1,2]
        输出：4
        示例 3 ：

        输入：nums = [1]
        输出：1

        提示：

        1 <= nums.length <= 3 * 104
        -3 * 104 <= nums[i] <= 3 * 104
        除了某个元素只出现一次以外，其余每个元素均出现两次。*/
public class SingleNumber136 {
    public int singleNumber(int[] nums) {
        int result = 0;
        // 相同数异或后为0，任意数字与0异或仍为原数字
        for (int i : nums) {
            result ^= i;
        }
        return result;
    }

    public static void main(String[] args) {
        SingleNumber136 solution = new SingleNumber136();
        int[] nums1 = {2,2,1};
        System.out.println(solution.singleNumber(nums1));
        int[] nums2 = {4,1,2,1,2};
        System.out.println(solution.singleNumber(nums2));
        int[] nums3 = {1};
        System.out.println(solution.singleNumber(nums3));
    }
}

137. 只出现一次的数字 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/*给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。

        你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。

        示例 1：

        输入：nums = [2,2,3,2]
        输出：3
        示例 2：

        输入：nums = [0,1,0,1,0,1,99]
        输出：99

        提示：

        1 <= nums.length <= 3 * 104
        -231 <= nums[i] <= 231 - 1
        nums 中，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次*/
public class SingleNumberII137 {
    public int singleNumber(int[] nums) {
        int result = 0;
        // 初始化一个32位数组count，用于记录每一位上的出现次数
        int[] count = new int[32];

        for (int i = 0; i < 32; i++) {
            for (int num : nums) {
                // 对每个数字的每一位进行统计
                count[i] += (num >> i) & 1;
            }
            // 对count数组的每一位取模3，得到的结果就是只出现一次的数字在该位上的二进制表示
            result |= (count[i] % 3) << i;
        }

        return result;
    }

    public static void main(String[] args) {
        SingleNumberII137 solution = new SingleNumberII137();

        int[] nums1 = {2, 2, 3, 2};
        System.out.println(solution.singleNumber(nums1));  // Output: 3

        int[] nums2 = {0, 1, 0, 1, 0, 1, 99};
        System.out.println(solution.singleNumber(nums2));  // Output: 99
    }
}

201. 数字范围按位与 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*给你两个整数 left 和 right ，表示区间 [left, right] ，返回此区间内所有数字 按位与 的结果（包含 left 、right 端点）。

        示例 1：

        输入：left = 5, right = 7
        输出：4
        示例 2：

        输入：left = 0, right = 0
        输出：0
        示例 3：

        输入：left = 1, right = 2147483647
        输出：0

        提示：

        0 <= left <= right <= 231 - 1*/
public class BitwiseAndOfNumbersRange201 {
    public int rangeBitwiseAnd(int left, int right) {
        int shift = 0;
        while (left < right) {
            left >>= 1;
            right >>= 1;
            shift++;
        }
        return left << shift;
    }
    public static void main(String[] args) {
        BitwiseAndOfNumbersRange201 solution = new BitwiseAndOfNumbersRange201();

        System.out.println(solution.rangeBitwiseAnd(5, 7));  // Output: 4
        System.out.println(solution.rangeBitwiseAnd(0, 0 ));  // Output: 0
        System.out.println(solution.rangeBitwiseAnd(1, 2147483647));  // Output: 0
    }
}

3.21 数学 Mathematics

9. 回文数 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

        回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

        例如，121 是回文，而 123 不是。

        示例 1：

        输入：x = 121
        输出：true
        示例 2：

        输入：x = -121
        输出：false
        解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
        示例 3：

        输入：x = 10
        输出：false
        解释：从右向左读, 为 01 。因此它不是一个回文数。

        提示：

        -231 <= x <= 231 - 1

        进阶：你能不将整数转为字符串来解决这个问题吗？*/
public class PalindromeNumber9 {
    public boolean isPalindrome(int x) {
        String string = String.valueOf(x);
        int left = 0, right = string.length() - 1;
        while (left <= right) {
            char a = string.charAt(left++);
            char b = string.charAt(right--);
            if (a != b) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        PalindromeNumber9 solution = new PalindromeNumber9();

        System.out.println(solution.isPalindrome(121));  // Output: true
        System.out.println(solution.isPalindrome(-121));  // Output: false
        System.out.println(solution.isPalindrome(10));  // Output: false
    }
}

66. 加一 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/*定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

        最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

        你可以假设除了整数 0 之外，这个整数不会以零开头。

        示例 1：

        输入：digits = [1,2,3]
        输出：[1,2,4]
        解释：输入数组表示数字 123。
        示例 2：

        输入：digits = [4,3,2,1]
        输出：[4,3,2,2]
        解释：输入数组表示数字 4321。
        示例 3：

        输入：digits = [0]
        输出：[1]

        提示：

        1 <= digits.length <= 100
        0 <= digits[i] <= 9*/
public class PlusOne66 {
    public int[] plusOne(int[] digits) {
        int n = digits.length;

        // 从数组的最后一位开始向前遍历
        for (int i = n - 1; i >= 0; i--) {
            // 在当前位置加1
            digits[i]++;
            // 如果加1后不产生进位，直接返回结果
            if (digits[i] < 10) {
                return digits;
            }
            // 如果加1后产生进位，当前位置变为0，继续向前进位
            digits[i] = 0;
        }

        // 如果最高位产生了进位，需要在数组的最前面插入一个新的最高位1
        int[] result = new int[n + 1];
        result[0] = 1;

        return result;
    }

    public static void printList(int[] digits) {
        for (int i : digits) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        PlusOne66 solution = new PlusOne66();

        int[] digits1 = {1,2,3};
        printList(solution.plusOne(digits1));  // Output: [1,2,4]
        int[] digits2 = {4,3,2,1};
        printList(solution.plusOne(digits2));  // Output: [4,3,2,2]
        int[] digits3 = {0};
        printList(solution.plusOne(digits3));  // Output: [1]
        int[] digits4 = {9};
        printList(solution.plusOne(digits4));  // Output: [1,0]
    }
}

172. 阶乘后的零 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/*给定一个整数 n ，返回 n! 结果中尾随零的数量。

        提示 n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1

        示例 1：

        输入：n = 3
        输出：0
        解释：3! = 6 ，不含尾随 0
        示例 2：

        输入：n = 5
        输出：1
        解释：5! = 120 ，有一个尾随 0
        示例 3：

        输入：n = 0
        输出：0

        提示：

        0 <= n <= 104

        进阶：你可以设计并实现对数时间复杂度的算法来解决此问题吗？*/
public class FactorialTrailingZeroes172 {
    public int trailingZeroes(int n) {
        // 统计n!中因子5的个数，即末尾零的个数
        int count = 0;

        // 每个因子5都会贡献一个零，所以只需统计5的倍数的个数
        while (n > 0) {
            n /= 5;
            count += n;
        }

        return count;
    }
    public static void main(String[] args) {
        // O(logn)
        FactorialTrailingZeroes172 solution = new FactorialTrailingZeroes172();

        System.out.println(solution.trailingZeroes(3));  // Output: 0
        System.out.println(solution.trailingZeroes(5));  // Output: 1
        System.out.println(solution.trailingZeroes(0));  // Output: 0
    }
}

69. x 的平方根 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

        由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

        注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

        示例 1：

        输入：x = 4
        输出：2
        示例 2：

        输入：x = 8
        输出：2
        解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

        提示：

        0 <= x <= 231 - 1*/
public class SqrtX69 {
    public int mySqrt(int x) {
        // 使用二分查找法求解
        if (x == 0) {
            return 0;
        }
        // 定义一个范围在[1, x]之间的左右指针。
        int left = 1, right = x;
        while (left <= right) {
            // 在每一步中，通过计算中间值mid，将问题缩小为[left, mid-1]或[mid+1, right]。
            int mid = left + (right - left) / 2;
            // 对于每个mid值，都计算mid的平方sqrt，然后与x进行比较。
            int sqrt = x / mid;

            if (mid == sqrt) {
                // 如果mid的平方等于x，直接返回mid。
                return mid;
            } else if (mid < sqrt) {
                // 如果mid的平方小于x，说明平方根应该在[mid+1, right]之间，将left指针更新为mid+1。
                left = mid + 1;
            } else {
                // 如果mid的平方大于x，说明平方根应该在[left, mid-1]之间，将right指针更新为mid-1。
                right = mid - 1;
            }
        }

        // O(logn)
        return right;
    }
    public static void main(String[] args) {
        SqrtX69 solution = new SqrtX69();

        // Test Case 1
        int result1 = solution.mySqrt(4);
        System.out.println(result1);  // Output: 2

        // Test Case 2
        int result2 = solution.mySqrt(8);
        System.out.println(result2);  // Output: 2
    }
}

50. Pow(x, n) <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。

        示例 1：

        输入：x = 2.00000, n = 10
        输出：1024.00000
        示例 2：

        输入：x = 2.10000, n = 3
        输出：9.26100
        示例 3：

        输入：x = 2.00000, n = -2
        输出：0.25000
        解释：2 = 1/2 = 1/4 = 0.25


        提示：

        -100.0 < x < 100.0
        -231 <= n <= 231-1
        n 是一个整数
        要么 x 不为零，要么 n > 0 。
        -104 <= xn <= 104*/
public class PowxN50 {
    public double myPow(double x, int n) {
        // 超出时间限制
        //if (n == 0) {
        //    return 1;
        //}
        //if (n < 0) {
        //    x = 1 / x;
        //    n = -n;
        //}
        //double base = x;
        //while (n > 1) {
        //    x *= base;
        //    n--;
        //}
        //return x;
        // 2.分治解法
        // 处理特殊情况
        if (n == 0) {
            return 1.0;
        }
        // 将 n 转为 long 类型，避免负整数越界问题
        long N = n;

        // 如果 n 为负数，转换为正数，并取倒数
        if (n < 0) {
            x = 1 / x;
            N = -N;
        }

        // O(logn)
        return fastPow(x, N);
    }

    private double fastPow(double x, long n) {
        // 递归结束条件
        if (n == 0) {
            return 1.0;
        }

        // 分治，降低问题规模
        double half = fastPow(x, n / 2);

        // 根据奇偶性，分情况计算结果
        if (n % 2 == 0) {
            return half * half;
        } else {
            return half * half * x;
        }
    }

    public static void main(String[] args) {
        PowxN50 solution = new PowxN50();

        // Test Case 1
        double result1 = solution.myPow(2.00000, 10);
        System.out.println(result1);  // Output: 1024.00000

        // Test Case 2
        double result2 = solution.myPow(2.10000, 3);
        System.out.println(result2);  // Output: 9.26100

        // Test Case 3
        double result3 = solution.myPow(2.00000, -2);
        System.out.println(result3);  // Output: 0.25000
    }
}

149. 直线上最多的点数 <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/*给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。

        示例 1：

        输入：points = [[1,1],[2,2],[3,3]]
        输出：3
        示例 2：

        输入：points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
        输出：4

        提示：

        1 <= points.length <= 300
        points[i].length == 2
        -104 <= xi, yi <= 104
        points 中的所有点 互不相同*/
public class MaxPointsOnALine149 {
    public int maxPoints(int[][] points) {
        // 通过枚举每一对点，计算它们的斜率，并使用哈希表进行统计，找出具有最多点数的斜率
        // 特殊情况处理
        if (points.length <= 1) {
            return points.length;
        }

        int maxPoints = 1;

        // 遍历每个点 points[i]，以其为起点，计算与其他点之间的斜率。
        for (int i = 0; i < points.length; i++) {
            Map<String, Integer> slopeCount = new HashMap<>();
            int duplicatePoints = 0;
            int localMax = 1;

            for (int j = i + 1; j < points.length; j++) {
                int deltaX = points[j][0] - points[i][0];
                int deltaY = points[j][1] - points[i][1];

                if (deltaX == 0 && deltaY == 0) {
                    // 处理相同点的情况
                    duplicatePoints++;
                } else {
                    // 计算最简斜率，用字符串表示以避免浮点误差
                    int gcd = gcd(deltaX, deltaY);
                    String slope = (deltaX / gcd) + "/" + (deltaY / gcd);

                    // 更新斜率统计
                    slopeCount.put(slope, slopeCount.getOrDefault(slope, 1) + 1);
                    // 更新本轮局部最大值
                    localMax = Math.max(localMax, slopeCount.get(slope));
                }
            }

            // 更新全局最大值
            maxPoints = Math.max(maxPoints, localMax + duplicatePoints);
        }

        return maxPoints;
    }

    private int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    public static void main(String[] args) {
        //  O(N^2)
        MaxPointsOnALine149 solution = new MaxPointsOnALine149();

        // Test Case 1
        int[][] points1 = {{1, 1}, {2, 2}, {3, 3}};
        int result1 = solution.maxPoints(points1);
        System.out.println(result1);  // Output: 3

        // Test Case 2
        int[][] points2 = {{1, 1}, {3, 2}, {5, 3}, {4, 1}, {2, 3}, {1, 4}};
        int result2 = solution.maxPoints(points2);
        System.out.println(result2);  // Output: 4
    }
}

3.22 一维动态规划 One-dimensional Dynamic Programming

动态规划（Dynamic Programming，简称 DP）是一种解决问题的优化方法，它通常用于处理具有重叠子问题和最优子结构性质的问题。动态规划主要通过将原问题分解成子问题，先解决子问题，然后保存子问题的解，最后利用这些子问题的解构建原问题的解。

动态规划的基本思路包含以下步骤：

  1. 定义状态： 明确问题的状态，找到问题的子结构。状态通常是原问题中变化的量，同时要保证问题的最优解能够通过子问题的最优解得到。
  2. 设计状态转移方程： 根据问题的子结构，定义状态之间的关系。状态转移方程描述了问题的最优子结构，通过递推关系求解问题。
  3. 初始化： 初始化问题的边界状态，通常是最简单的情况，从而能够递推得到更复杂的状态。
  4. 计算最终解： 根据状态转移方程和初始状态，计算得到原问题的解。
  5. 优化空间： 由于动态规划算法通常会使用数组来存储状态，可以考虑优化空间复杂度，例如使用滚动数组等方法。

动态规划广泛应用于求解最优化问题，如最短路径、最长公共子序列、背包问题等。

斐波那契数列：是一个经典的动态规划问题，其中每个数等于前两个数的和。数列的前几项为：0, 1, 1, 2, 3, 5, 8, 13, 21, …

  • 状态定义：设 dp[i] 表示第 i 个斐波那契数。
  • 状态转移方程：dp[i] = dp[i-1] + dp[i-2]
  • 初始化：dp[0] = 0, dp[1] = 1
  • 计算最终解：遍历 i，计算 dp[i] 直到达到目标。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Fibonacci {
    public static int fib(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 static void main(String[] args) {
        int n = 5;
        System.out.println("Fibonacci of " + n + ": " + fib(n)); // Output: 5
    }
}

70. 爬楼梯 <easy>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/*假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

        每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

        示例 1：

        输入：n = 2
        输出：2
        解释：有两种方法可以爬到楼顶。
        1. 1 阶 + 1 阶
        2. 2 阶
        示例 2：

        输入：n = 3
        输出：3
        解释：有三种方法可以爬到楼顶。
        1. 1 阶 + 1 阶 + 1 阶
        2. 1 阶 + 2 阶
        3. 2 阶 + 1 阶

        提示：

        1 <= n <= 45*/
public class ClimbingStairs70 {
    public int climbStairs(int n) {
        if (n <= 2) {
            return n;
        }

        // 用dp表示爬到第i阶楼梯的方法总数
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;

        for (int i = 3; i <= n; i++) {
            // 爬到第i阶楼梯的方法数等于爬到第i-1阶楼梯的方法数加上爬到第i-2阶楼梯的方法数
            dp[i] = dp[i - 1] + dp[i - 2];
        }

        return dp[n];
    }

    public static void main(String[] args) {
        // O(n)
        ClimbingStairs70 solution = new ClimbingStairs70();

        // Test Case 1
        int result1 = solution.climbStairs(2);
        System.out.println(result1);  // Output: 2

        // Test Case 2
        int result2 = solution.climbStairs(3);
        System.out.println(result2);  // Output: 3
    }
}

198. 打家劫舍 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/*你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

        给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

        示例 1：

        输入：[1,2,3,1]
        输出：4
        解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
        偷窃到的最高金额 = 1 + 3 = 4 。
        示例 2：

        输入：[2,7,9,3,1]
        输出：12
        解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
        偷窃到的最高金额 = 2 + 9 + 1 = 12 。

        提示：

        1 <= nums.length <= 100
        0 <= nums[i] <= 400*/
public class HouseRobber198 {
    public int rob(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }

        if (nums.length == 2) {
            return Math.max(nums[0], nums[1]);
        }

        int[] dp = new int[nums.length + 1];
        dp[1] = nums[0];
        dp[2] = Math.max(nums[0], nums[1]);

        for (int i = 3; i <= nums.length; i++) {
            // 第i号房屋的最大金额等于第i-1房屋的金额与第i加上第i-2个房屋的金额中的最大值
            dp[i] = Math.max(dp[i - 1], dp[i - 2]+ nums[i-1]);
        }

        return dp[nums.length];
    }

    public static void main(String[] args) {
        // O(n)
        HouseRobber198 solution = new HouseRobber198();

        // Test Case 1
        int[] nums = {1,2,3,1};
        int result1 = solution.rob(nums);
        System.out.println(result1);  // Output: 4

        // Test Case 2
        int[] nums1 = {2,7,9,3,1};
        int result2 = solution.rob(nums1);
        System.out.println(result2);  // Output: 12
    }
}

139. 单词拆分 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

        注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

        示例 1：

        输入: s = "leetcode", wordDict = ["leet", "code"]
        输出: true
        解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
        示例 2：

        输入: s = "applepenapple", wordDict = ["apple", "pen"]
        输出: true
        解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
        注意，你可以重复使用字典中的单词。
        示例 3：

        输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
        输出: false

        提示：

        1 <= s.length <= 300
        1 <= wordDict.length <= 1000
        1 <= wordDict[i].length <= 20
        s 和 wordDict[i] 仅由小写英文字母组成
        wordDict 中的所有字符串 互不相同*/
public class WordBreak139 {
    public boolean wordBreak(String s, List<String> wordDict) {
        if (s == null || s.length() == 0 || wordDict == null || wordDict.isEmpty()) {
            return false;
        }

        int n = s.length();
        // dp[i] 表示字符串 s 的前 i 个字符是否可以拆分成 wordDict 中的单词
        boolean[] dp = new boolean[n + 1];
        dp[0] = true; // 空字符串可以被拆分

        // 遍历字符串每个字符
        for (int i = 1; i <= n; i++) {
            // 遍历字典表
            for (String word : wordDict) {
                int len = word.length();
                // 当前字符数大于等于单词长度，且与单词相等，并且单词前的第i-len个字符可以匹配
                if (i >= len && dp[i - len] && s.substring(i - len, i).equals(word)) {
                    dp[i] = true;
                    break;
                }
            }
        }

        return dp[n];
    }

    public static void main(String[] args) {
        WordBreak139 solution = new WordBreak139();

        // Test Case 1
        String s1 = "leetcode";
        List<String> wordDict1 = Arrays.asList("leet", "code");
        boolean result1 = solution.wordBreak(s1, wordDict1);
        System.out.println(result1);  // Output: true

        // Test Case 2
        String s2 = "applepenapple";
        List<String> wordDict2 = Arrays.asList("apple", "pen");
        boolean result2 = solution.wordBreak(s2, wordDict2);
        System.out.println(result2);  // Output: true

        // Test Case 3
        String s3 = "catsandog";
        List<String> wordDict3 = Arrays.asList("cats", "dog", "sand", "and", "cat");
        boolean result3 = solution.wordBreak(s3, wordDict3);
        System.out.println(result3);  // Output: false
    }
}

322. 零钱兑换 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/*给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

        计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

        你可以认为每种硬币的数量是无限的。

        示例 1：

        输入：coins = [1, 2, 5], amount = 11
        输出：3
        解释：11 = 5 + 5 + 1
        示例 2：

        输入：coins = [2], amount = 3
        输出：-1
        示例 3：

        输入：coins = [1], amount = 0
        输出：0

        提示：

        1 <= coins.length <= 12
        1 <= coins[i] <= 231 - 1
        0 <= amount <= 104*/
public class CoinChange322 {
    public int coinChange(int[] coins, int amount) {
        if (amount < 0) {
            return -1; // 无法凑成负数金额
        }

        // dp[i]表示凑成金额i所需的最少硬币个数
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;

        // 遍历硬币集合
        for (int coin : coins) {
            // 从coin遍历到amount，若i-coin不是初始状态，则更新其最小硬币数
            for (int i = coin; i <= amount; i++) {
                if (dp[i - coin] != Integer.MAX_VALUE) {
                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
                }
            }
        }

        return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
    }

    public static void main(String[] args) {
        CoinChange322 solution = new CoinChange322();

        // Test Case 1
        int[] coins1 = {1, 2, 5};
        int amount1 = 11;
        int result1 = solution.coinChange(coins1, amount1);
        System.out.println(result1);  // Output: 3

        // Test Case 2
        int[] coins2 = {2};
        int amount2 = 3;
        int result2 = solution.coinChange(coins2, amount2);
        System.out.println(result2);  // Output: -1

        // Test Case 3
        int[] coins3 = {1};
        int amount3 = 0;
        int result3 = solution.coinChange(coins3, amount3);
        System.out.println(result3);  // Output: 0
    }
}

300. 最长递增子序列 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/*给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

        子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

        示例 1：

        输入：nums = [10,9,2,5,3,7,101,18]
        输出：4
        解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
        示例 2：

        输入：nums = [0,1,0,3,2,3]
        输出：4
        示例 3：

        输入：nums = [7,7,7,7,7,7,7]
        输出：1

        提示：

        1 <= nums.length <= 2500
        -104 <= nums[i] <= 104

        进阶：

        你能将算法的时间复杂度降低到 O(n log(n)) 吗?*/
public class LongestIncreasingSubsequence300 {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }

        int n = nums.length;
        // dp[i]表示以nums[i]结尾的最长递增子序列的长度
        int[] dp = new int[n];
        // 初始时，将dp数组填充为1，表示每个元素本身构成一个递增子序列
        Arrays.fill(dp, 1);

        int maxLength = 1;

        for (int i = 1; i < n; i++) {
            // 遍历i之前所有元素，只要小于nums[i]，就更新最大长度
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLength = Math.max(maxLength, dp[i]);
        }

        return maxLength;
    }

    public static void main(String[] args) {
        LongestIncreasingSubsequence300 solution = new LongestIncreasingSubsequence300();

        // Test Case 1
        int[] nums1 = {10, 9, 2, 5, 3, 7, 101, 18};
        int result1 = solution.lengthOfLIS(nums1);
        System.out.println(result1);  // Output: 4

        // Test Case 2
        int[] nums2 = {0, 1, 0, 3, 2, 3};
        int result2 = solution.lengthOfLIS(nums2);
        System.out.println(result2);  // Output: 4

        // Test Case 3
        int[] nums3 = {7, 7, 7, 7, 7, 7, 7};
        int result3 = solution.lengthOfLIS(nums3);
        System.out.println(result3);  // Output: 1
    }
}

3.23 多维动态规划 Multi-dimensional Dynamic Programming

120. 三角形最小路径和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/*给定一个三角形 triangle ，找出自顶向下的最小路径和。

        每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

        示例 1：

        输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
        输出：11
        解释：如下面简图所示：
        2
        3 4
        6 5 7
        4 1 8 3
        自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
        示例 2：

        输入：triangle = [[-10]]
        输出：-10

        提示：

        1 <= triangle.length <= 200
        triangle[0].length == 1
        triangle[i].length == triangle[i - 1].length + 1
        -104 <= triangle[i][j] <= 104

        进阶：

        你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？*/
public class Triangle120 {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();

        // 使用一维数组 dp 存储每一层的最小路径和
        int[] dp = new int[n];

        // 初始化 dp 数组为最后一层的值
        for (int i = 0; i < n; i++) {
            dp[i] = triangle.get(n - 1).get(i);
        }

        // 从倒数第二层开始更新 dp 数组
        for (int i = n - 2; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                // 更新 dp 数组为当前位置的值加上下一层的最小路径和
                dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
            }
        }

        return dp[0];
    }

    public static void main(String[] args) {
        Triangle120 solution = new Triangle120();

        // Test Case 1
        List<List<Integer>> triangle1 = Arrays.asList(
                Arrays.asList(2),
                Arrays.asList(3, 4),
                Arrays.asList(6, 5, 7),
                Arrays.asList(4, 1, 8, 3)
        );
        int result1 = solution.minimumTotal(triangle1);
        System.out.println(result1);  // Output: 11

        // Test Case 2
        List<List<Integer>> triangle2 = Arrays.asList(
                Arrays.asList(-10)
        );
        int result2 = solution.minimumTotal(triangle2);
        System.out.println(result2);  // Output: -10
    }
}

64. 最小路径和 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/*给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

        说明：每次只能向下或者向右移动一步。

        示例 1：

        输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
        输出：7
        解释：因为路径 1→3→1→1→1 的总和最小。
        示例 2：

        输入：grid = [[1,2,3],[4,5,6]]
        输出：12

        提示：

        m == grid.length
        n == grid[i].length
        1 <= m, n <= 200
        0 <= grid[i][j] <= 200*/
public class MinimumPathSum64 {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;

        // 初始化 dp 数组，dp[i][j] 表示从左上角到达坐标 (i, j) 的最小路径和
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];

        // 初始化第一行和第一列
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }

        // 动态规划递推公式：dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }

        return dp[m - 1][n - 1];
    }

    public static void main(String[] args) {
        MinimumPathSum64 solution = new MinimumPathSum64();

        // Test Case 1
        int[][] grid1 = {
                {1, 3, 1},
                {1, 5, 1},
                {4, 2, 1}
        };
        int result1 = solution.minPathSum(grid1);
        System.out.println(result1);  // Output: 7

        // Test Case 2
        int[][] grid2 = {
                {1, 2, 3},
                {4, 5, 6}
        };
        int result2 = solution.minPathSum(grid2);
        System.out.println(result2);  // Output: 12
    }
}

63. 不同路径 II <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

        机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

        现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

        网格中的障碍物和空位置分别用 1 和 0 来表示。

        示例 1：

        输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
        输出：2
        解释：3x3 网格的正中间有一个障碍物。
        从左上角到右下角一共有 2 条不同的路径：
        1. 向右 -> 向右 -> 向下 -> 向下
        2. 向下 -> 向下 -> 向右 -> 向右
        示例 2：

        输入：obstacleGrid = [[0,1],[0,0]]
        输出：1

        提示：

        m == obstacleGrid.length
        n == obstacleGrid[i].length
        1 <= m, n <= 100
        obstacleGrid[i][j] 为 0 或 1*/
public class UniquePathsII63 {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;

        // 创建一个二维数组dp，dp[i][j]表示从起点到达坐标(i, j)的不同路径数
        int[][] dp = new int[m][n];

        // 初始化第一行和第一列
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
            dp[i][0] = 1;
        }
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
            dp[0][j] = 1;
        }

        // 动态规划递推公式：dp[i][j] = dp[i-1][j] + dp[i][j-1]，如果 obstacleGrid[i][j] == 0
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 0) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }

        return dp[m - 1][n - 1];
    }

    public static void main(String[] args) {
        UniquePathsII63 solution = new UniquePathsII63();

        // Test Case 1
        int[][] obstacleGrid1 = {
                {0, 0, 0},
                {0, 1, 0},
                {0, 0, 0}
        };
        int result1 = solution.uniquePathsWithObstacles(obstacleGrid1);
        System.out.println(result1);  // Output: 2

        // Test Case 2
        int[][] obstacleGrid2 = {
                {0, 1},
                {0, 0}
        };
        int result2 = solution.uniquePathsWithObstacles(obstacleGrid2);
        System.out.println(result2);  // Output: 1
    }
}

5. 最长回文子串 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/*给你一个字符串 s，找到 s 中最长的回文子串。

        如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

        示例 1：

        输入：s = "babad"
        输出："bab"
        解释："aba" 同样是符合题意的答案。
        示例 2：

        输入：s = "cbbd"
        输出："bb"

        提示：

        1 <= s.length <= 1000
        s 仅由数字和英文字母组成*/
public class LongestPalindromicSubstring5 {
    public String longestPalindrome(String s) {
        // 解法1动态规划 O(n^2)
        //if (s == null || s.length() == 0) {
        //    return "";
        //}
        //
        //int n = s.length();
        ////  dp[i][j] 表示字符串从第 i 个字符到第 j 个字符是否构成回文子串
        //boolean[][] dp = new boolean[n][n];
        //int start = 0;
        //int end = 0;
        //
        //for (int len = 1; len <= n; len++) {
        //    for (int i = 0; i <= n - len; i++) {
        //        int j = i + len - 1;
        //
        //        // 判断首尾两个字符是否相等，且剩余部分是回文
        //        if (len == 1 || (s.charAt(i) == s.charAt(j) && (len == 2 || dp[i + 1][j - 1]))) {
        //            dp[i][j] = true;
        //
        //            if (len > end - start + 1) {
        //                start = i;
        //                end = j;
        //            }
        //        }
        //    }
        //}
        //
        //return s.substring(start, end + 1);

        // 解法2中心扩展法 O(n^2)
        if (s == null || s.length() == 0) {
            return "";
        }

        int start = 0;
        int end = 0;

        // 对于每个字符，分别以该字符为中心，或者以该字符与其右侧字符之间为中心，进行扩展，找到最长的回文子串。在扩展的过程中，通过比较左右两侧的字符是否相等，来确定是否构成回文。通过不断更新最长回文子串的起始位置和结束位置，最终得到最长回文子串。
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i);
            int len2 = expandAroundCenter(s, i, i + 1);
            int len = Math.max(len1, len2);

            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }

        return s.substring(start, end + 1);
    }

    private int expandAroundCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1;
    }

    public static void main(String[] args) {
        LongestPalindromicSubstring5 solution = new LongestPalindromicSubstring5();

        // Test Case 1
        String s1 = "babad";
        String result1 = solution.longestPalindrome(s1);
        System.out.println(result1);  // Output: "bab" or "aba"

        // Test Case 2
        String s2 = "cbbd";
        String result2 = solution.longestPalindrome(s2);
        System.out.println(result2);  // Output: "bb"
    }
}

97. 交错字符串 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/*给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。

        两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：

        s = s1 + s2 + ... + sn
        t = t1 + t2 + ... + tm
        |n - m| <= 1
        交错 是 s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...
        注意：a + b 意味着字符串 a 和 b 连接。

        示例 1：

        输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
        输出：true
        示例 2：

        输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
        输出：false
        示例 3：

        输入：s1 = "", s2 = "", s3 = ""
        输出：true

        提示：

        0 <= s1.length, s2.length <= 100
        0 <= s3.length <= 200
        s1、s2、和 s3 都由小写英文字母组成

        进阶：您能否仅使用 O(s2.length) 额外的内存空间来解决它?*/
public class InterleavingString97 {
    public boolean isInterleave(String s1, String s2, String s3) {
        // O(m * n)
        if (s1.length() + s2.length() != s3.length()) {
            return false;
        }

        // dp[i][j] 表示 s1 的前 i 个字符和 s2 的前 j 个字符是否可以交错形成 s3 的前 i + j 个字符
        boolean[][] dp = new boolean[s1.length() + 1][s2.length() + 1];

        for (int i = 0; i <= s1.length(); i++) {
            for (int j = 0; j <= s2.length(); j++) {
                if (i == 0 && j == 0) {
                    // 空字符串和空字符串交错为一个空字符串
                    dp[i][j] = true;
                } else if (i == 0) {
                    // 对于第一行，只要当前字符和 s3 对应位置的字符相等，就可以继续扩展
                    dp[i][j] = dp[i][j - 1] && s2.charAt(j - 1) == s3.charAt(i + j - 1);
                } else if (j == 0) {
                    // 对于第一列，只要当前字符和 s3 对应位置的字符相等，就可以继续扩展
                    dp[i][j] = dp[i - 1][j] && s1.charAt(i - 1) == s3.charAt(i + j - 1);
                } else {
                    // 如果 s1.charAt(i - 1) == s3.charAt(i + j - 1)，则 dp[i][j] = dp[i - 1][j]；
                    // 如果 s2.charAt(j - 1) == s3.charAt(i + j - 1)，则 dp[i][j] = dp[i][j - 1]。
                    dp[i][j] = (dp[i - 1][j] && s1.charAt(i - 1) == s3.charAt(i + j - 1))
                            || (dp[i][j - 1] && s2.charAt(j - 1) == s3.charAt(i + j - 1));
                }
            }
        }

        return dp[s1.length()][s2.length()];
    }

    public static void main(String[] args) {
        InterleavingString97 solution = new InterleavingString97();

        // Test Case 1
        String s1 = "aabcc";
        String s2 = "dbbca";
        String s3 = "aadbbcbcac";
        System.out.println(solution.isInterleave(s1, s2, s3));  // Output: true

        // Test Case 2
        String s4 = "aabcc";
        String s5 = "dbbca";
        String s6 = "aadbbbaccc";
        System.out.println(solution.isInterleave(s4, s5, s6));  // Output: false

        // Test Case 3
        String s7 = "";
        String s8 = "";
        String s9 = "";
        System.out.println(solution.isInterleave(s7, s8, s9));  // Output: true
    }
}

72. 编辑距离 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数  。

        你可以对一个单词进行如下三种操作：

        插入一个字符
        删除一个字符
        替换一个字符

        示例 1：

        输入：word1 = "horse", word2 = "ros"
        输出：3
        解释：
        horse -> rorse (将 'h' 替换为 'r')
        rorse -> rose (删除 'r')
        rose -> ros (删除 'e')
        示例 2：

        输入：word1 = "intention", word2 = "execution"
        输出：5
        解释：
        intention -> inention (删除 't')
        inention -> enention (将 'i' 替换为 'e')
        enention -> exention (将 'n' 替换为 'x')
        exention -> exection (将 'n' 替换为 'c')
        exection -> execution (插入 'u')

        提示：

        0 <= word1.length, word2.length <= 500
        word1 和 word2 由小写英文字母组成*/
public class EditDistance72 {
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();

        // dp[i][j] 表示将 word1 的前 i 个字符转换为 word2 的前 j 个字符所需的最少操作数
        int[][] dp = new int[m + 1][n + 1];

        // 初始化第一行
        for (int j = 1; j <= n; j++) {
            // 从0转0=0开始，word2每多一个字符，结果+1
            dp[0][j] = dp[0][j - 1] + 1;
        }

        // 初始化第一列
        for (int i = 1; i <= m; i++) {
            // 从0转0=0开始，word1每多一个字符，结果+1
            dp[i][0] = dp[i - 1][0] + 1;
        }

        // 动态规划填表
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    // 字符相等，则不需转换，直接等于前面一位的结果
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    // 字符不相等，则取word1少一个元素，word2少一个元素，二者都少一个元素的最小结果+1
                    dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                }
            }
        }

        return dp[m][n];
    }

    public static void main(String[] args) {
        EditDistance72 solution = new EditDistance72();

        // Test Case 1
        String word1_1 = "horse";
        String word2_1 = "ros";
        System.out.println(solution.minDistance(word1_1, word2_1));  // Output: 3

        // Test Case 2
        String word1_2 = "intention";
        String word2_2 = "execution";
        System.out.println(solution.minDistance(word1_2, word2_2));  // Output: 5
    }
}

123. 买卖股票的最佳时机 III <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

        设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

        注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

        示例 1:

        输入：prices = [3,3,5,0,0,3,1,4]
        输出：6
        解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
        随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
        示例 2：

        输入：prices = [1,2,3,4,5]
        输出：4
        解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
        注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
        因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
        示例 3：

        输入：prices = [7,6,4,3,1]
        输出：0
        解释：在这个情况下, 没有交易完成, 所以最大利润为 0。
        示例 4：

        输入：prices = [1]
        输出：0

        提示：

        1 <= prices.length <= 105
        0 <= prices[i] <= 105*/
public class BestTimeToBuyAndSellStockIII123 {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }

        int n = prices.length;

        // dp数组：dp[j][k]表示在第i天结束时，最多进行j次交易，持有状态为k（0表示不持有，1表示持有）时的最大利润
        int[][] dp = new int[3][2];

        // 初始化第一天，未进行交易，持有状态为0的情况
        dp[0][0] = 0;

        // 初始化第一天，未进行交易，持有状态为1的情况，即购买了股票
        dp[0][1] = -prices[0];

        // 初始化第一天，进行了一次交易，持有状态为0的情况，因为是第一天，不可能卖出
        dp[1][0] = 0;

        // 初始化第一天，进行了一次交易，持有状态为1的情况，即购买了股票
        dp[1][1] = -prices[0];

        // 初始化第一天，进行了两次交易，持有状态为0的情况，因为是第一天，不可能卖出
        dp[2][0] = 0;

        // 初始化第一天，进行了两次交易，持有状态为1的情况，即购买了股票
        dp[2][1] = -prices[0];

        for (int i = 1; i < n; i++) {
            // 第i天未进行交易，持有状态为0的情况
            dp[0][0] = dp[0][0];

            // 第i天未进行交易，持有状态为1的情况，可能是前一天持有，或者前一天卖出了
            dp[0][1] = Math.max(dp[0][1], dp[0][0] - prices[i]);

            // 第i天进行了一次交易，持有状态为0的情况，可能是前一天进行了一次交易，或者前一天持有，然后卖出了
            dp[1][0] = Math.max(dp[1][0], dp[0][1] + prices[i]);

            // 第i天进行了一次交易，持有状态为1的情况，可能是前一天进行了两次交易，或者前一天进行了一次交易，然后买入了
            dp[1][1] = Math.max(dp[1][1], dp[1][0] - prices[i]);

            // 第i天进行了两次交易，持有状态为0的情况，可能是前一天进行了两次交易，或者前一天进行了一次交易，然后卖出了
            dp[2][0] = Math.max(dp[2][0], dp[1][1] + prices[i]);

            // 第i天进行了两次交易，持有状态为1的情况，可能是前一天进行了两次交易，或者前一天进行了两次交易，然后买入了
            dp[2][1] = Math.max(dp[2][1], dp[2][0] - prices[i]);
        }

        // 最终结果在最后一天，未进行交易，持有状态为0的情况中
        return Math.max(Math.max(dp[0][0], dp[1][0]), dp[2][0]);
    }

    public static void main(String[] args) {
        BestTimeToBuyAndSellStockIII123 solution = new BestTimeToBuyAndSellStockIII123();

        // Test Case 1
        int[] prices1 = {3, 3, 5, 0, 0, 3, 1, 4};
        System.out.println(solution.maxProfit(prices1));  // Output: 6

        // Test Case 2
        int[] prices2 = {1, 2, 3, 4, 5};
        System.out.println(solution.maxProfit(prices2));  // Output: 4

        // Test Case 3
        int[] prices3 = {7, 6, 4, 3, 1};
        System.out.println(solution.maxProfit(prices3));  // Output: 0

        // Test Case 4
        int[] prices4 = {1};
        System.out.println(solution.maxProfit(prices4));  // Output: 0
    }
}

188. 买卖股票的最佳时机 IV <hard>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/*给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。

        设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。

        注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

        示例 1：

        输入：k = 2, prices = [2,4,1]
        输出：2
        解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
        示例 2：

        输入：k = 2, prices = [3,2,6,5,0,3]
        输出：7
        解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
        随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

        提示：

        1 <= k <= 100
        1 <= prices.length <= 1000
        0 <= prices[i] <= 1000*/
public class BestTimeToBuyAndSellStockIv188 {
    public int maxProfit(int k, int[] prices) {
        int n = prices.length;

        // 如果交易次数 k 大于等于数组长度的一半，说明可以尽情地进行交易
        if (k >= n / 2) {
            int maxProfit = 0;
            for (int i = 1; i < n; i++) {
                if (prices[i] > prices[i - 1]) {
                    maxProfit += prices[i] - prices[i - 1];
                }
            }
            return maxProfit;
        }

        // dp数组：dp[i][j]表示在第i天结束时，最多进行j次交易时的最大利润
        int[][] dp = new int[k + 1][2];

        // 初始化第一天，未进行交易，持有状态为0的情况
        for (int i = 0; i <= k; i++) {
            dp[i][0] = 0;
        }

        // 初始化第一天，未进行交易，持有状态为1的情况，即购买了股票
        for (int i = 0; i <= k; i++) {
            dp[i][1] = -prices[0];
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= k; j++) {
                // 第i天未进行交易，持有状态为0的情况
                dp[j][0] = Math.max(dp[j][0], dp[j][1] + prices[i]);

                // 第i天未进行交易，持有状态为1的情况，可能是前一天持有，或者前一天卖出了
                dp[j][1] = Math.max(dp[j][1], dp[j - 1][0] - prices[i]);
            }
        }

        // 最终结果在最后一天，未进行交易，持有状态为0的情况中
        return dp[k][0];
    }

    public static void main(String[] args) {
        BestTimeToBuyAndSellStockIv188 solution = new BestTimeToBuyAndSellStockIv188();

        // Test Case 1
        int k1 = 2;
        int[] prices1 = {2, 4, 1};
        System.out.println(solution.maxProfit(k1, prices1));  // Output: 2

        // Test Case 2
        int k2 = 2;
        int[] prices2 = {3, 2, 6, 5, 0, 3};
        System.out.println(solution.maxProfit(k2, prices2));  // Output: 7
    }
}

221. 最大正方形 <medium>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。

        示例 1：

        输入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
        输出：4
        示例 2：

        输入：matrix = [["0","1"],["1","0"]]
        输出：1
        示例 3：

        输入：matrix = [["0"]]
        输出：0

        提示：

        m == matrix.length
        n == matrix[i].length
        1 <= m, n <= 300
        matrix[i][j] 为 '0' 或 '1'*/
public class MaximalSquare221 {
    public int maximalSquare(char[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }

        int m = matrix.length;
        int n = matrix[0].length;
        int maxSide = 0;

        // dp数组：dp[i][j]表示以matrix[i][j]为右下角的正方形的最大边长
        int[][] dp = new int[m][n];

        // 初始化第一列
        for (int i = 0; i < m; i++) {
            dp[i][0] = matrix[i][0] - '0';
            maxSide = Math.max(maxSide, dp[i][0]);
        }

        // 初始化第一行
        for (int j = 0; j < n; j++) {
            dp[0][j] = matrix[0][j] - '0';
            maxSide = Math.max(maxSide, dp[0][j]);
        }

        // 递推计算dp数组
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == '1') {
                    // 状态转移方程：dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
                    dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                    maxSide = Math.max(maxSide, dp[i][j]);
                }
            }
        }

        return maxSide * maxSide;
    }

    public static void main(String[] args) {
        MaximalSquare221 solution = new MaximalSquare221();

        // Test Case 1
        char[][] matrix1 = {
                {'1', '0', '1', '0', '0'},
                {'1', '0', '1', '1', '1'},
                {'1', '1', '1', '1', '1'},
                {'1', '0', '0', '1', '0'}
        };
        System.out.println(solution.maximalSquare(matrix1));  // Output: 4

        // Test Case 2
        char[][] matrix2 = {
                {'0', '1'},
                {'1', '0'}
        };
        System.out.println(solution.maximalSquare(matrix2));  // Output: 1

        // Test Case 3
        char[][] matrix3 = {
                {'0'}
        };
        System.out.println(solution.maximalSquare(matrix3));  // Output: 0
    }
}

-————————————–

参考：

🔗后端面试的所有知识点