一个数组，只考虑速度，怎么获取最大值以及最小值？
方法一：使用 Math.max 和 Math.min 结合扩展运算符
Math.max 和 Math.min 是 JavaScript 内置函数，可分别返回一组数中的最大值和最小值。结合扩展运算符 ... 能直接处理数组。
function getMaxMinByMath(arr: number[]): [number, number] {
const max = Math.max(...arr);
const min = Math.min(...arr);
return [max, min];
}
const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
const [max, min] = getMaxMinByMath(arr);
console.log(`最大值: ${max}, 最小值: ${min}`);
复杂度分析
- 时间复杂度：O(n)，扩展运算符会遍历数组中的每个元素。
- 空间复杂度：O(n)，在内部会展开数组。
- 优点：代码简洁直观。
- 缺点：当数组非常大时，可能会导致栈溢出错误，因为扩展运算符会一次性将数组元素展开。
方法二：手动遍历数组
手动遍历数组，在遍历过程中记录最大值和最小值。
function getMaxMinByLoop(arr: number[]): [number, number] {
if (arr.length === 0) {
return [NaN, NaN];
}
let max = arr[0];
let min = arr[0];
for (let i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
return [max, min];
}
const arr2 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
const [max2, min2] = getMaxMinByLoop(arr2);
console.log(`最大值: ${max2}, 最小值: ${min2}`);
复杂度分析
- 时间复杂度：O(n)，需要遍历数组中的每个元素一次。
- 空间复杂度：O(1)，只使用了常数级的额外变量。
- 优点：不会有栈溢出风险，性能稳定，适合处理大规模数组。
- 缺点：代码相对冗长。
方法三：使用 reduce 方法
reduce 方法可以对数组中的每个元素执行一个自定义的回调函数，并将结果累积起来。
function getMaxMinByReduce(arr: number[]): [number, number] {
if (arr.length === 0) {
return [NaN, NaN];
}
const [max, min] = arr.reduce(([accMax, accMin], current) => {
return [
current > accMax ? current : accMax,
current < accMin ? current : accMin
];
}, [arr[0], arr[0]]);
return [max, min];
}
const arr3 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
const [max3, min3] = getMaxMinByReduce(arr3);
console.log(`最大值: ${max3}, 最小值: ${min3}`);
复杂度分析
- 时间复杂度：，会遍历数组中的每个元素。
- 空间复杂度：，只使用了常数级的额外空间。
- 优点：代码相对简洁，利用了数组的高阶函数。
- 缺点：对于不熟悉
reduce方法的开发者来说，代码理解成本较高。
方法四： 排序法
先对数组进行排序，排序后数组的第一个元素就是最小值，最后一个元素就是最大值。
function findMaxMinBySort(arr) {
if (arr.length === 0) {
return [null, null];
}
const sortedArr = [...arr].sort((a, b) => a - b);
const min = sortedArr[0];
const max = sortedArr[sortedArr.length - 1];
return [max, min];
}
const array3 = [4, 6, 1, 9, 3];
const [maxResult, minResult] = findMaxMinBySort(array3);
console.log(`最大值: ${maxResult}, 最小值: ${minResult}`);
复杂度分析：
- 时间复杂度：O(nlogn)，主要是排序操作的时间复杂度，常见的排序算法如快速排序、归并排序的平均时间复杂度为 O(nlogn)。
- 空间复杂度：O(n)，通常排序算法需要额外的空间来存储排序后的数组。
方法五：冒泡排序
function getMaxMinByBubble(arr) {
if (arr.length === 0) {
return [null, null];
}
let len = arr.length;
// 通过一轮冒泡找出最大值
for (let i = 0; i < len - 1; i++) {
if (arr[i] > arr[i + 1]) {
// 交换 arr[i] 和 arr[i + 1]
let temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
// 经过一轮冒泡，最后一个元素是最大值
let max = arr[len - 1];
// 通过一轮反向冒泡找出最小值
for (let i = len - 1; i > 0; i--) {
if (arr[i] < arr[i - 1]) {
// 交换 arr[i] 和 arr[i - 1]
let temp = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = temp;
}
}
// 经过一轮反向冒泡，第一个元素是最小值
let min = arr[0];
return [max, min];
}
const array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
const [maxValue, minValue] = getMaxMinByBubble(array);
console.log(`最大值: ${maxValue}, 最小值: ${minValue}`);
复杂度分析
- 时间复杂度：O(n)。虽然使用了冒泡排序的思想，但我们只进行了两轮线性的遍历操作，每轮遍历数组中的元素一次，所以总的时间复杂度为O(n) ，其中 n 是数组的长度。
- 空间复杂度：O(1)。只使用了常数级的额外变量（如
temp用于交换元素），没有使用额外的数据结构来存储大量数据，所以空间复杂度为常数级别。
性能对比与选择建议
- 若数组规模较小，使用
Math.max和Math.min结合扩展运算符的方法代码最为简洁。 - 若数组规模较大，手动遍历数组的方法性能更稳定，不会有栈溢出风险。
reduce方法在性能上和手动遍历相近，但代码简洁性介于前两者之间，适合熟悉高阶函数的开发者。-
排序法虽然能得到结果，但排序操作的时间复杂度较高，在只需要找出最大值和最小值的场景下，不是最优选择。
-
冒泡虽然能获取到最大值和最小值，但相比直接遍历数组比较元素大小（手动遍历数组的方法），代码会更复杂一些，因为涉及到元素交换的操作。不过它依然是一种可行的方式，并且能在 的时间复杂度内完成任务。而和使用
Math.max与Math.min或者reduce方法相比，代码的简洁性较差，但原理更加直观易懂，适合对算法原理进行学习和理解。