JavaScript 数组最大值算法

（卓越的人一大优点是：在不利与艰难的遭遇里百折不饶。——贝多芬）

// 给定一个数组，数组内元素可以以一个或多个组合成连续的子数组，要求在这批子数组中找到累加后最大值的数组并输出结果
const array = [1, -2, 2, 0, -5, 3, -2, 7, 1, -2, 10];

/**
 * 整体思路
 * 首先这是一个依次累加的数组
 * 比如1是一个子数组，1+-2是一个子数组，1+-2+2又是一个子数组，直到数组取完为止
 * 然后从-2开始是一个子数组，-2+2是一个子数组，-2+2+0又是一个子数组，直到数组取完为止
 * 接下来记录每一个子数组的下标，对子数字的累加值进行排序，输出最大的子数组和最大值
 */

// 获取最大值和子数组
const getResult = (childList, resultList) => {
  let len = resultList.length;
  // 冒泡排序
  for (let i = 0; i < len; i++) {
    if (resultList[i] > resultList[i + 1]) {
      const temp = resultList[i];
      const tempResult = [...childList[i]];
      resultList[i] = resultList[i + 1];
      resultList[i + 1] = temp;
      childList[i] = childList[i + 1];
      childList[i + 1] = tempResult;
    }
    if (i === len) {
      i = -1;
      len -= 1;
    }
  }
  return { childList, resultList };
}

// 写法一 时间复杂度为On^2
(() => {
  const list = [];
  const resultList = [];
  for (let i = 0; i < array.length; i++) {
    let item = array[i];
    // 放入数组中，用于后续展示
    list.push([item]);
    // 初始化子数组
    const tempList = [item];
    // 计算结果放入数组中
    resultList.push(item);
    for (let j = i + 1; j < array.length; j++) {
      if (typeof array[j] === 'number') {
        // 计算累加结果
        item += array[j];
        // 追加数组
        tempList.push(array[j]);
        // 重新拷贝数组
        const newTempList = [...tempList];
        // 将每次的自己加入数组
        list.push(newTempList);
        resultList.push(item);
      }
    }
  }
  const result = getResult(list, resultList);
  console.log(result.childList[result.childList.length - 1], result.resultList[result.resultList.length - 1]); // [ 3, -2, 7, 1, -2, 10 ] 17
})();

// 写法二 时间复杂度为On 但写法复杂，理解难度也上升
(() => {
  // 基数下标
  let baseNumberIndex = -1;
  // 基数
  let baseNumber = null;
  // 开始基数
  let startIndex = -1;
  // 子数组集
  let tempList = [];
  const list = [];
  const resultList = [];
  for (let i = 1; i < array.length; i++) {
    // 计算累加结果
    baseNumber += array[i];
    // 追加数组
    tempList.push(array[i]);
    // 将每次的自己加入数组，需要重新拷贝
    list.push([...tempList]);
    resultList.push(baseNumber);
    // 每遍历完一次，进行一次初始化，从第二位开始进行依次计算
    if (i === 1 || i === array.length - 1) {
      // 累计基数下标
      baseNumberIndex += 1;
      // 迭代基数
      baseNumber = array[baseNumberIndex];
      // 初始化子数组
      tempList = [baseNumber];
      // 放入数组中，作为子数组
      list.push(tempList);
      // 计算结果放入数组中
      resultList.push(baseNumber);
      startIndex += 1;
      i = startIndex;
    }
    // 外层到最后一个时就结束循环
    if (baseNumberIndex === array.length - 1) {
      break;
    }
  }
  const result = getResult(list, resultList);
  console.log(result.childList[result.childList.length - 1], result.resultList[result.resultList.length - 1]); // [ 3, -2, 7, 1, -2, 10 ] 17
})();