算法_最大子数组&合并排序数组

最大子数组

难度：简单

描述：

给定一个整数数组，找到一个具有最大和的子数组，返回其最大和。

样例：

给出数组[−2,2,−3,4,−1,2,1,−5,3]，符合要求的子数组为[4,−1,2,1]，其最大和为 6

思路分析：

本题只要找出最大和即可，保存两个值，一个为元素之间相加的值(需比较元素相加的值与当前元素的大小)，一个为最大值。

代码：

/**
 * @param nums: A list of integers
 * @return: A integer indicate the sum of max subarray
 */
const maxSubArray = function(nums) {
  let max = nums[0]; // 初始化最大值
  let newMax = nums[0]; // 数组元素相加的缓存值
  for (let i = 1; i < nums.length; i++) {
    newMax = Math.max(newMax + nums[i], nums[i]); // 相加是否大于当前值
    max = Math.max(newMax, max); // 与最大值相比
  }
  return max;
};

第二种方法更难理解点，可以扩展一下思路：

/**
 * @param nums: A list of integers
 * @return: A integer indicate the sum of max subarray
 */
const maxSubArray = function(nums) {
  var nSum = nums[0]; // 数组元素相加的缓存值
  var nMax = nSum; // 初始化最大值
  for (var i = 1; i < nums.length; i++) {
    var curNum = nums[i]; // 当前元素
    if (curNum >= 0) nSum = nSum > 0 ? nSum + curNum : curNum;
    // 如果两个值都大于0 两个值相加。否则就取后一个大于0的
    else nSum = nSum < curNum ? curNum : nSum + curNum; // 如果新加的值小于0 判断结果是否大于新加的值 小于的话就改为新加的值
    nMax = Math.max(nMax, nSum); // 最大值与数组元素相加值比较
  }
  return nMax;
};

最大和的数组：

如果你想把最大和的数组都找出来，你需要保存数组的开始下标和结束下标，这里我演示了第一个方法，下面那个方法也是一样：

const maxSubArray = function(nums) {
  let max = {
    num: nums[0],
    start: 0,
    end: 1 // 结束的下标 后面要切割数组 需比当前下标+1.把当前值也切割
  };
  let newMax = {
    num: nums[0],
    start: 0,
    end: 1
  };
  for (let i = 1; i < nums.length; i++) {
    if (newMax.num + nums[i] > nums[i]) {
      // 相加大于当前值 缓存改值和结束下标
      newMax.num = newMax.num + nums[i];
      newMax.end = i + 1;
    } else {
      // 小于当前值 重置start end
      newMax.num = nums[i];
      newMax.start = i;
      newMax.end = i + 1;
    }
    // 最大值被超过 把值赋给最大值
    if (max.num < newMax.num) {
      max.num = newMax.num;
      max.start = newMax.start;
      max.end = newMax.end;
    }
  }
  let arr = nums.slice(max.start, max.end); // 找出最大和的子数组
  return max.num; // 子数组的最大和
};

觉得还不错的话，给我的点个star吧

合并排序数组

难度：简单

描述：

合并两个排序的整数数组 A 和 B 变成一个新的排序数组。

样例：

给出A=[1,2,3,4]，B=[2,4,5,6]，返回 [1,2,2,3,4,4,5,6]

题目分析：

注意 A 和 B 本来就是排序好的数组，最简单的就是用sort排序了。

`sort`排序

把两个数组合并成一个数组
用 sort 升序进行排序。

const mergeSortedArray = function(A, B) {
  let newArr = A.concat(B); // 合并数组
  return newArr.sort((a, b) => {
    return a - b; // sort排序
  });
};

先对比完一个数组：

初始两个变量分别对应一个数组，进入循环
i 和 j 不会同时递增，只在对应数组元素打败另一数组元素时才会递增，只要打败一个即可，因为两个数组一开始就是排序好的
i 和 j 必须有一个超过对应数组长度(这样至少有一个数组的元素被逐一比较过)
如果一个数组那边超过长度，会退出循环，但是可能由一方的长度还有剩余（比如一个元素打败另一数组的所有元素），所以我们需要将长度有剩余的数组剩下的元素全都 push 到新数组中(因为一开始就排序好的，后面出场的只会更强)

const mergeSortedArray = function(A, B) {
  var i, j;
  var arr = [];
  for (i = 0, j = 0; i < A.length && j < B.length; ) {
    // i或者j必须有一个超过对应数组长度 才退出循环 所以至少有一个数组的元素被逐一比较
    if (A[i] < B[j]) {
      // 下面两种写法是一样的
      arr.push(A[i]);
      i++;
    } else {
      arr.push(B[j++]); // 这里会先把j赋值给B[j]， 然后再j++
    }
  }

  // 上面至少有一个数组已经比较了每个元素 如果还有一方长度有剩余 直接push进来就可以(AB一开始就是排序好的数组)
  while (i < A.length) {
    arr.push(A[i++]);
  }
  while (j < B.length) {
    arr.push(B[j++]);
  }
  return arr;
};