一个数组，只考虑速度，怎么获取最大值以及最小值？

方法一：使用 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 方法相比，代码的简洁性较差，但原理更加直观易懂，适合对算法原理进行学习和理解。