JAVA:实现使用快速排序算法获取给定数组中的第 k 个最大或第 k 个最小元素算法（附带源码）
项目背景详细介绍
在算法与工程实践中，经常遇到“选择问题”（selection problem）——在一组无序元素中找到第 k 个最小元素（或第 k 个最大元素）。这是基础但非常实用的问题，应用场景包括但不限于：
-
数据分析中的分位数计算（比如中位数、四分位数、百分位数等）；
-
大数据流中近似 top-k 或 exact top-k 的查找（结合外部存储或流式算法）；
-
实时统计系统（查找第 k 大用于阈值判断或报警）；
-
算法面试题（Quickselect 常作为高频考点）；
-
数据库引擎或操作系统的高效选择子例程。
常见的解决方法有三类：
-
排序后索引法：对数组排序然后直接取第 k 个值（时间 O(n log n)，实现简单且稳定）；
-
堆（PriorityQueue）法：维持大小为 k 的堆（针对第 k 小使用最大堆，针对第 k 大使用最小堆），时间 O(n log k)，在 k 很小时非常高效，且适合流式输入；
-
Quickselect（基于快速排序的分区）：平均时间 O(n)、空间 O(1)（原地），但最坏情况 O(n²)（通常通过随机化枢轴避免最坏情况），是求第 k 个元素的经典最优解，也是面试中重要知识点。
本项目以教学与工程实用为目标：既要详细讲清楚 Quickselect 的原理与实现细节，又要提供可直接拷贝运行的工程代码（包括 int 原始类型与泛型实现），并提供排序法与堆法作为对比、边界检查、异常处理及命令行示例，便于你写博客或课堂讲稿使用。
项目需求详细介绍
本项目应满足以下具体需求（逐条实现并在代码中标注）：
-
功能
-
quickSelectKthSmallest(int[] arr, int k): 使用原地 Quickselect（随机枢轴）返回第 k 小（k 为 1-based）。 -
quickSelectKthLargest(int[] arr, int k): 返回第 k 大（可通过转换逻辑实现）。 -
泛型版本：
quickSelectKthSmallest(T[] arr, int k)（T extends Comparable），支持任意可比较对象。 -
排序备选：
sortThenPickKthSmallest(...)（复制数组并排序后取值）。 -
堆备选：
heapKthSmallest(...)与heapKthLargest(...)（使用 PriorityQueue，适用于流或 k 很小的情况）。 -
生成前 k 个最小/最大元素（可选方法，用于验证或批量输出）。
-
-
健壮性
-
对
null、空数组、k 越界等情况做清晰校验并抛出IllegalArgumentException。 -
对输入数组是否会被修改有说明（Quickselect 原地修改，若不希望修改则建议传入副本）。
-
-
性能与数值细节
-
Quickselect 使用随机枢轴以降低最坏情况概率（实现随机化版本）。
-
对于大量重复元素或特定分布，给出注意事项（例如三向划分/荷兰国旗分区优化可提供）。
-
相关技术详细介绍
在实现与讲解中需要涉及以下技术要点与理论背景：
-
快速排序（QuickSort）与 Quickselect 关系
-
Quickselect 的核心思想来源于快速排序的分区（partition）操作：通过枢轴将数组划分为小于枢轴、等于枢轴与大于枢轴三部分，然后只在包含目标索引的那一侧继续搜索，从而避免对不必要部分排序，达到平均 O(n) 的选择时间。
-
-
分区（Partition）策略
-
常用的分区有 Lomuto（简单、常见）和 Hoare（更高效但实现细节有差异）。在存在大量重复值时，三向分区（Dutch National Flag）能大幅减少不必要交换，提高效率。实现中我们使用 Lomuto 风格并在注释中指出三向分区的可选优化点。
-
-
随机化枢轴（Randomized Pivot）
-
为避免输入的恶意或特殊分布（例如已排序或逆序）导致 Quickselect 退化到 O(n²)，实现中随机选择枢轴索引。该随机化将平均时间复杂度保持在 O(n)。
-
-
堆法（PriorityQueue）
-
在寻找第 k 个最小（k 小）值时构建大小为 k 的最大堆（Java 中用
PriorityQueue的逆序比较器可实现）。对于第 k 大，使用最小堆。复杂度 O(n log k)，当 k << n 时很有优势，且可扩展为处理数据流（在线算法）。
-
-
排序（Sort）法
-
排序复杂度 O(n log n)，但实现简单可靠且易于验证。常用于对照、当 n 规模不大或当代码可读性优先时。
-
-
泛型支持
-
Java 泛型实现需通过
T extends Comparable<? super T>来支持任何可比较对象。比较使用compareTo，注意避免装箱/拆箱产生性能开销（对于基本类型如 int，优先使用原生 int[] 版本以获得更好性能）。
-
-
稳定性与原地修改说明
-
Quickselect 原地分区会修改输入数组；若调用方不允许修改原数组，需先复制一份再调用。排序法在本文实现中通过复制数组避免修改原数组。
-
-
复杂度汇总
-
Quickselect：平均 O(n)，空间 O(1)（原地）；最坏 O(n²)（概率极低，随机化可降低风险）。
-
排序法：O(n log n)，空间 O(n)（若复制）。
-
堆法：O(n log k)，空间 O(k)。
-
实现思路详细介绍
我们将按教学思路实现以下部分，代码中会明确标注每一步的教学要点与边界检查：
-
Quickselect 主流程（int[]）
-
对外提供
quickSelectKthSmallest(int[] arr, int k)：检查参数后调用内部quickSelectKthSmallest(arr, left, right, targetIndex)；内部采用循环（非递归）或递归两种形式均可，本文以循环+partition 的方式实现以避免深度递归。 -
partition使用 Lomuto 风格：将选定的 pivot 移到右端，然后将小于 pivot 的元素移到左侧，最后将 pivot 放回storeIndex处并返回storeIndex。 -
通过比较
pivotNewIndex与targetIndex决定向左或向右继续搜索。 -
在选择枢轴时使用
Random来随机选取pivotIndex。 -
对于第 k 大元素，直接将 k 转换为第 (n - k + 1) 小再调用相同逻辑。
-
-
泛型 Quickselect（T extends Comparable）
-
与 int 版逻辑一致，但需要对比较和交换做泛型适配。
-
因为 Java 泛型中无法直接创建
T[]的空数组，方法会接受T[] arr并在原数组上操作（或需复制数组）。
-
-
排序法备选
-
sortThenPickKthSmallest(int[] arr, int k)：复制数组、调用Arrays.sort、返回copy[k-1]。说明复制是为了避免修改原始数组。
-
-
堆法备选
-
对于第 k 小：使用
PriorityQueue<Integer>并传入Comparator.reverseOrder()（最大堆行为）。遍历数组：把元素加入堆，若堆大小超过 k 则弹出堆顶，以保证堆中始终是 k 个最小元素；最后堆顶即为第 k 小。 -
对于第 k 大：使用默认最小堆，逻辑类似。
-
-
三向分区（可选优化）
-
在数组包含大量重复元素时，使用三向分区算法（Dutch National Flag）可把等于 pivot 的元素分到中间，从而减少后续搜索范围。本实现将在代码注释中说明如何扩展为三向分区并给出参考实现思路（为保持代码清晰，主实现使用 Lomuto，但会在注释给出三向分区伪码/提示）。
-
-
CLI 与测试
-
main中将演示：Quickselect 获取第 k 小/大、排序法、堆法的结果对比，并输出每种方法的耗时（纳秒）以供课堂展示。也会演示在对 Quickselect 不希望修改原数组时的处理方法（传入副本）。
-
-
错误处理与提示
-
对
k越界、空数组、null 输入抛IllegalArgumentException。 -
在文档中指明 Quickselect 原地修改数组，若使用者不想修改需自行复制。排序法实现默认复制以保证安全。
-
完整实现代码
/* ============================================================
文件: KthElementProject.java
说明: 使用 Quickselect（基于快速排序的分区）获取数组中第 k 个最小/最大元素。
同时提供排序法与堆法作为备选，并提供泛型版本。
特性:
- Quickselect 原地实现（随机枢轴以避免最坏情况）
- 泛型支持：T extends Comparable<? super T>
- 排序备选（复制数组避免修改原数组）
- 堆备选（适合 k 很小或流式处理）
- 完整参数校验与易读注释，适合教学与博客直接拷贝
编译: javac KthElementProject.java
运行: java KthElementProject
============================================================ */
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.Comparator;
public class KthElementProject {
// -------------------------
// 文件: KthSelector.java
// 说明: 提供多种 kth 选择算法（Quickselect, sort, heap），支持 int[] 与泛型 T[]
// -------------------------
public static class KthSelector {
// 共享的随机数生成器（用于随机化枢轴）
private static final Random RNG = new Random();
/* =====================================================
int[] 版本 - Quickselect（原地，返回第 k 小，k 为 1-based）
API: quickSelectKthSmallest(int[] arr, int k)
说明: 会修改传入的数组（原地分区）。若不想修改，请传入 Arrays.copyOf(arr, arr.length)
复杂度: 平均 O(n)，最坏 O(n^2)（概率极低）
===================================================== */
public static int quickSelectKthSmallest(int[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
// targetIndex 为 0-based（第 k 小对应索引 k-1）
int targetIndex = k - 1;
int left = 0, right = n - 1;
while (left <= right) {
// 随机选择枢轴索引，减少最坏情况出现概率
int pivotIndex = left + RNG.nextInt(right - left + 1);
int pivotNewIndex = partitionLomuto(arr, left, right, pivotIndex);
if (pivotNewIndex == targetIndex) {
return arr[pivotNewIndex];
} else if (pivotNewIndex > targetIndex) {
right = pivotNewIndex - 1;
} else {
left = pivotNewIndex + 1;
}
}
// 理论上不可能到这里
throw new RuntimeException("Quickselect 未能找到第 " + k + " 小元素（内部错误）");
}
// Lomuto partition 实现（将 pivot 移到末端，再把小于 pivot 的元素移动到前部）
private static int partitionLomuto(int[] arr, int left, int right, int pivotIndex) {
int pivotValue = arr[pivotIndex];
swap(arr, pivotIndex, right);
int storeIndex = left;
for (int i = left; i < right; i++) {
if (arr[i] < pivotValue) {
swap(arr, storeIndex, i);
storeIndex++;
}
}
swap(arr, storeIndex, right);
return storeIndex;
}
private static void swap(int[] arr, int i, int j) {
int t = arr[i]; arr[i] = arr[j]; arr[j] = t;
}
/* =====================================================
int[] 版本 - Quickselect 第 k 大（k 为 1-based）
实现: 转换成第 (n - k + 1) 小问题
===================================================== */
public static int quickSelectKthLargest(int[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
// 第 k 大等于第 (n - k + 1) 小
return quickSelectKthSmallest(arr, n - k + 1);
}
/* =====================================================
int[] 版本 - 排序后取值（安全但较慢）
说明: 复制数组以避免修改原数组
复杂度: O(n log n)
===================================================== */
public static int sortThenPickKthSmallest(int[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
int[] copy = Arrays.copyOf(arr, n);
Arrays.sort(copy);
return copy[k - 1];
}
/* =====================================================
int[] 版本 - 堆法（适用于 k 很小或数据流）
- 第 k 小: 使用大小为 k 的最大堆（保留 k 个最小元素）
- 第 k 大: 使用大小为 k 的最小堆（保留 k 个最大元素）
复杂度: O(n log k)
===================================================== */
public static int heapKthSmallest(int[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
// 最大堆保持 k 个最小元素（堆顶为当前第 k 小）
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, Comparator.reverseOrder());
for (int v : arr) {
if (maxHeap.size() < k) {
maxHeap.offer(v);
} else if (v < maxHeap.peek()) {
maxHeap.poll();
maxHeap.offer(v);
}
}
return maxHeap.peek();
}
public static int heapKthLargest(int[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
// 最小堆保持 k 个最大元素（堆顶为当前第 k 大）
PriorityQueue<Integer> minHeap = new PriorityQueue<>(k);
for (int v : arr) {
if (minHeap.size() < k) {
minHeap.offer(v);
} else if (v > minHeap.peek()) {
minHeap.poll();
minHeap.offer(v);
}
}
return minHeap.peek();
}
/* =====================================================
泛型版本（T extends Comparable<? super T>）
- quickSelectKthSmallest(T[] arr, int k)
- sortThenPickKthSmallest(T[] arr, int k)
注意: Java 泛型无法在运行时创建泛型数组，方法使用传入的数组进行原地操作
===================================================== */
public static <T extends Comparable<? super T>> T quickSelectKthSmallest(T[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
int targetIndex = k - 1;
int left = 0, right = n - 1;
while (left <= right) {
int pivotIndex = left + RNG.nextInt(right - left + 1);
int pivotNewIndex = partitionLomutoGeneric(arr, left, right, pivotIndex);
if (pivotNewIndex == targetIndex) {
return arr[pivotNewIndex];
} else if (pivotNewIndex > targetIndex) {
right = pivotNewIndex - 1;
} else {
left = pivotNewIndex + 1;
}
}
throw new RuntimeException("Quickselect 未能找到第 " + k + " 小元素（内部错误）");
}
private static <T extends Comparable<? super T>> int partitionLomutoGeneric(T[] arr, int left, int right, int pivotIndex) {
T pivotValue = arr[pivotIndex];
swapGeneric(arr, pivotIndex, right);
int storeIndex = left;
for (int i = left; i < right; i++) {
if (arr[i].compareTo(pivotValue) < 0) {
swapGeneric(arr, storeIndex, i);
storeIndex++;
}
}
swapGeneric(arr, storeIndex, right);
return storeIndex;
}
private static <T> void swapGeneric(T[] arr, int i, int j) {
T tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;
}
public static <T extends Comparable<? super T>> T sortThenPickKthSmallest(T[] arr, int k) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
// 复制数组以避免修改原数组
T[] copy = Arrays.copyOf(arr, n);
Arrays.sort(copy);
return copy[k - 1];
}
/* =====================================================
堆法泛型版本（使用 Comparator）
- heapKthSmallestGeneric(T[] arr, int k, Comparator<? super T> cmp)
- 若 cmp 为 null，则使用 Comparable
===================================================== */
public static <T> T heapKthSmallestGeneric(T[] arr, int k, Comparator<? super T> cmp) {
if (arr == null) throw new IllegalArgumentException("arr 不能为 null");
int n = arr.length;
if (n == 0) throw new IllegalArgumentException("数组长度必须 >= 1");
if (k < 1 || k > n) throw new IllegalArgumentException("k 必须在 1.." + n + " 之间");
Comparator<? super T> comparator = cmp;
if (comparator == null) {
//noinspection unchecked
comparator = (a, b) -> ((Comparable<T>) a).compareTo(b);
}
// 为了获得第 k 小，使用大小为 k 的最大堆（即使用 comparator 的反向）
PriorityQueue<T> maxHeap = new PriorityQueue<>(k, comparator.reversed());
for (T v : arr) {
if (maxHeap.size() < k) {
maxHeap.offer(v);
} else if (comparator.compare(v, maxHeap.peek()) < 0) {
maxHeap.poll();
maxHeap.offer(v);
}
}
return maxHeap.peek();
}
/* =====================================================
三向分区提示（Dutch National Flag） - 可选优化
场景: 当数组含大量重复值时，三向分区能显著提高效率。
伪代码提示（教学用途，未作为主实现）：
- 将数组分为 < pivot、= pivot、> pivot 三段
- 如果 targetIndex 在 < 段，继续左边；在 > 段，继续右边；若在 = 段，直接返回
===================================================== */
} // End class KthSelector
// -------------------------
// 文件: MainDemo.java
// 说明: 提供 main() 函数用于演示并比较 Quickselect / sort / heap 三种方法
// -------------------------
public static void main(String[] args) {
System.out.println("KthElementProject Demo");
int[] arr = {7, 10, 4, 3, 20, 15};
int k = 3; // 查找第 3 小（期望结果 7）
// Quickselect（原地）
int[] arrForQuick = Arrays.copyOf(arr, arr.length);
long t0 = System.nanoTime();
int kthQuick = KthSelector.quickSelectKthSmallest(arrForQuick, k);
long t1 = System.nanoTime();
// 排序法（复制后排序）
long t2 = System.nanoTime();
int kthSort = KthSelector.sortThenPickKthSmallest(arr, k);
long t3 = System.nanoTime();
// 堆法
long t4 = System.nanoTime();
int kthHeap = KthSelector.heapKthSmallest(arr, k);
long t5 = System.nanoTime();
System.out.println("数组: " + Arrays.toString(arr));
System.out.println("第 " + k + " 小（Quickselect） = " + kthQuick + "，耗时(ns)=" + (t1 - t0));
System.out.println("第 " + k + " 小（排序） = " + kthSort + "，耗时(ns)=" + (t3 - t2));
System.out.println("第 " + k + " 小（堆） = " + kthHeap + "，耗时(ns)=" + (t5 - t4));
// 第 k 大示例
int kth = 2;
int[] arrForQuick2 = Arrays.copyOf(arr, arr.length);
int kthLargest = KthSelector.quickSelectKthLargest(arrForQuick2, kth);
System.out.println("第 " + kth + " 大（Quickselect） = " + kthLargest);
// 泛型示例
Integer[] iarr = {7, 10, 4, 3, 20, 15};
Integer r = KthSelector.quickSelectKthSmallest(iarr, 3);
System.out.println("泛型数组第 3 小 = " + r);
// heap 泛型示例
Integer r2 = KthSelector.heapKthSmallestGeneric(iarr, 2, null); // 返回第 2 小
System.out.println("泛型堆法第 2 小 = " + r2);
// 注意: Quickselect 会修改传入数组（除非你先复制）。上面的示例中，我们
// 在调用 Quickselect 前复制了数组以保留原始数组不变。
}
}
代码详细解读
KthSelector（类）主要方法：
-
quickSelectKthSmallest(int[] arr, int k)
作用：在原地（会修改传入数组）使用 Quickselect 算法（随机枢轴 + Lomuto partition）查找并返回第 k 个最小元素（k 为 1-based）。对参数做完整校验（null、空数组、k 越界）。平均时间复杂度 O(n)，最坏 O(n²)。 -
quickSelectKthLargest(int[] arr, int k)
作用：返回第 k 个最大元素（k 为 1-based）。实现上把问题转换为第 (n - k + 1) 小元素并复用quickSelectKthSmallest。 -
partitionLomuto(int[] arr, int left, int right, int pivotIndex)（私有）
作用：执行 Lomuto 分区，将指定 pivot 移到其正确位置并返回该位置索引。分区过程将小于 pivot 的元素移动到左侧。 -
sortThenPickKthSmallest(int[] arr, int k)
作用：复制数组并排序，然后返回第 k 小元素（安全实现，时间 O(n log n)）。 -
heapKthSmallest(int[] arr, int k)与heapKthLargest(int[] arr, int k)
作用：使用堆（PriorityQueue）分别实现第 k 小与第 k 大的查找。第 k 小使用大小为 k 的最大堆，第 k 大使用大小为 k 的最小堆。适合 k 很小或流式输入。 -
泛型版本
quickSelectKthSmallest(T[] arr, int k)、sortThenPickKthSmallest(T[] arr, int k)、heapKthSmallestGeneric(T[] arr, int k, Comparator<? super T> cmp)
作用：在泛型数组上实现上述算法，支持任意可比较类型（使用Comparable或外部Comparator），提供和 int 版相同的功能与复杂度特性。
项目详细总结
-
Quickselect 是解决选择问题的首选方法：在不需要对数组完全排序的情况下，Quickselect 以线性平均时间 O(n) 找到第 k 个元素，且空间 O(1)（原地）。在面试与工程中都非常实用，但应注意随机化枢轴以避免退化到 O(n²)。
-
排序法与堆法是重要的备选方案：
-
排序法实现简单、稳定，适合 n 规模不大或对实现简洁性有强需求的场景。
-
堆法适合 k 很小、或数据以流式到达的场景，以及需要维护 sliding-top-k 的场景。
-
-
泛型支持使库通用：实现泛型版本可支持任意实现
Comparable的对象（如 Integer、Double、String、自定义类型），但对于性能敏感应用优先使用原生基本类型实现以避免装箱/拆箱开销。 -
工程实践建议：在生产中优先考虑代码可读性与鲁棒性：当 n 很大且数据分布未知时，使用随机化 Quickselect 或结合三向划分以提高稳定性；在对代码安全性有要求时使用排序法（复制原数组）避免副作用；在流式场景使用堆法。
项目常见问题及解答
Q1：Quickselect 会修改原数组吗？如果不允许修改怎么办？
A1：本实现的 Quickselect 是原地算法，会修改传入数组。若不想修改，请在调用前传入数组副本（Arrays.copyOf(arr, arr.length)），或者使用 sortThenPickKthSmallest（该方法内部复制了数组并排序）。
Q2：为何需要随机化枢轴？
A2：若枢轴固定或被输入数据控制，Quickselect 在最坏情况下会退化到 O(n²)（例如已排序数据），通过随机选择枢轴可以把退化概率降低到极小，从概率上保证平均 O(n)。
Q3：什么时候用堆法而不是 Quickselect？
A3：当 k 很小（例如 k=10，n=10^7）或者数据以流式到达（不能一次性全部存储）时，堆法（O(n log k)）非常合适。堆法也便于维护 online top-k。
Q4：数组含大量重复元素时 Quickselect 效率如何？
A4：当有大量重复值时，标准的二向分区（Lomuto/Hoare）可能多次在等于 pivot 的元素上浪费操作。此时可采用三向分区（Dutch National Flag）优化，把 = pivot 的元素一次性划分到中间，从而减少后续递归/循环范围。
Q5：泛型实现是否会比原生 int 慢很多？
A5：泛型实现涉及对象比较与可能的装箱/拆箱（若使用 Integer），因此在高性能场景原生基础类型会更快；泛型实现更适合通用库或对性能要求不苛刻的情形。
扩展方向与性能优化
-
三向分区实现：实现三向分区 Quickselect（Dutch National Flag）以在包含大量相等元素的数据上获得接近线性时间性能。它将数组划分为
< pivot、= pivot、> pivot三段，若 target 在=段可直接返回。 -
并行化/分布式：当数据量非常大且分布在多台机器上时，可采用分布式 top-k 框架：在每台机器上先局部筛选 top-k（或使用 Quickselect 局部选取），再合并各个本地 top-k（使用堆或分区）得到全局 top-k。
-
外部内存（外排序）与流式处理：当数据不能全部放入内存时，堆法配合外部排序或分片处理可实现外部 top-k。也可采用 approximate quantile 数据结构（如 t-digest）用于近似选择。
-
内存与缓存友好优化：实现时可减少交换次数、减少内存访问（例如使用局部性更好的分区或块分区），对大数组能提升常数项性能。
-
针对特殊硬件优化：在需要极致性能时，结合 SIMD、本地 BLAS 或 C/C++ 实现通过 JNI 调用，可以获得显著加速。
北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台
更多推荐
20
0- 0
已为社区贡献66条内容
所有评论(0)