leetcode 算法题581 (简单148) 最短无序连续子数组

leetcode 算法题581 (简单148) 最短无序连续子数组

• 题目介绍

给定一个整数数组，
你需要寻找一个连续的子数组，
如果对这个子数组进行升序排序，
那么整个数组都会变为升序排序。
你找到的子数组应是最短的，
请输出它的长度。

• 示例

输入: [2, 6, 4, 8, 10, 9, 15]
输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。

• 说明

输入的数组长度范围在 [1, 10,000]。
输入的数组可能包含重复元素 ，所以升序的意思是<=。

• 解法一

/**
 * @param {number[]} nums
 * @return {number}
 */
var findUnsortedSubarray = function(nums) {
  let start = 0, end = nums.length - 1, j = 1, startFlag = endFlag = true;
  while(startFlag && start < nums.length) {
    while(startFlag && start + j < nums.length ) {
      if(nums[start] <= nums[start + j]) {
        j++
      } else {
        start--;
        startFlag = false;
      }
    }
    if(startFlag) {
      j = 0
      start++;
    }
  }
  if(start === end + 1) {
      return 0;
  }
  j = 0;
  while(endFlag && end > 0) {
    while(endFlag && end - j >= 0 ) {
      if(nums[end] >= nums[end - j]) {
        j++
      } else {
        end++;
        endFlag = false;
      }
    }
    if(endFlag) {
      j = 0;
      end--;
    }
  }
  return end - start - 1;
};

执行用时 : 332 ms, 在所有 JavaScript 提交中击败了6.36%的用户

内存消耗 : 36.5 MB, 在所有 JavaScript 提交中击败了100.00%的用户

• 解法二

/**
 * @param {number[]} nums
 * @return {number}
 */
var findUnsortedSubarray = function(nums) {
  let temp = [...nums], i = 0, count = nums.length;
  temp.sort((n1, n2) => n1 - n2);
  while(i < nums.length) {
    if(temp[i] === nums[i++]) {
      count--;
    } else {
      break;
    }
  }
  if(count === 0) {
    return 0;
  }
  i = nums.length - 1;
  while(i > 0) {
    if(temp[i] === nums[i--]) {
      count--;
    } else {
      break;
    }
  }
  return count;
};

执行用时 : 184 ms, 在所有 JavaScript 提交中击败了32.95%的用户

内存消耗 : 38.4 MB, 在所有 JavaScript 提交中击败了54.84%的用户

• 解法三

/**
 * @param {number[]} nums
 * @return {number}
 */
var findUnsortedSubarray = function(nums) {
  let i = 0, temp = [], count = nums.length;
  while(i < nums.length - 1 && nums[i] <= nums[i + 1]) {
    temp.push(nums[i++]);
  }
  if(temp.length === count - 1) {
    return 0;
  }
  while(i < nums.length - 1 && temp.length) {
    while(temp.length && temp[temp.length - 1] > nums[i + 1]) {
      temp.length = temp.length - 1;
    }
    i++;
  }
  count -= temp.length;
  temp = [], i = nums.length - 1;
  while(i > 0 && nums[i] >= nums[i - 1]) {
    temp.push(nums[i--]);
  }
    console.log(i, temp, count)
  while(i > 0 && temp.length) {
    while(temp.length && temp[temp.length - 1] < nums[i - 1]) {
      temp.length = temp.length - 1;
    }
    i--;
  }
  return count - temp.length;
};

执行用时 : 120 ms, 在所有 JavaScript 提交中击败了69.94%的用户

内存消耗 : 38.9 MB, 在所有 JavaScript 提交中击败了19.35%的用户