JS解决数组算法的初始定义_js给定一个数组arrnums=[0,3,5,65,0,12,33,4],要求将所有为0的元素移动到-CSDN博客

本文链接：https://blog.csdn.net/YanMeiHe/article/details/103713568

移动零

给定一个数组 nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。必须在原数组上操作，不能拷贝额外的数组。尽量减少操作次数。

示例：

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

按顺序复制非零元素到原数组中，空位补零

//执行用时 :64 ms, 在所有 javascript 提交中击败了97.33%的用户
//内存消耗 :35.8 MB, 在所有 javascript 提交中击败了26.23%的用户
var moveZeroes = function (nums) {
  let count = 0;
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === 0) {
      nums.splice(i, 1);
      count++;
      i--;
    }
  }
  //填充count个0到末尾
  while (count-- != 0) {
    nums.push(0)
  }
};

//执行用时 :72 ms, 在所有 javascript 提交中击败了83.12%的用户
//内存消耗 :35.8 MB, 在所有 javascript 提交中击败了24.65%的用户
var moveZeroes = function (nums) {
  let len = nums.length;
  for (let i = 0; i < len; i++) {
    if (nums[i] === 0) {
      nums.push(nums.splice(i, 1))  
      len--;
      i--;
    }
  }
  return nums;
};

不消耗额外空间，即空间复杂度在O（1）,可以使用经典的双指针解决。快指针寻找非0元素，慢指针填充元素，最后慢指针将剩余的位置全部填充为0

//执行用时 :80 ms, 在所有 javascript 提交中击败了47.43%的用户
//内存消耗 :36.2 MB, 在所有 javascript 提交中击败了7.04%的用户
var moveZeroes = function (nums) {
  var i = 0, j = 0;
  for (; j < nums.length; j++) {
    if (nums[j] !== 0) {
      nums[i] = nums[j];
      i++;
    }
  }
  for (; i < j; i++) {
    nums[i] = 0;
  }
  return nums;
};

记录0的位置，遇到非0交换

//执行用时 :76 ms, 在所有 javascript 提交中击败了66.19%的用户
//内存消耗 :36.2 MB, 在所有 javascript 提交中击败了7.04%的用户
var moveZeroes = function (nums) {
  let n = 0,
    index = 0;
  for (let i = 0; i < nums.length; ++i) {
    if (nums[i] == 0) {
      n++;
      if (n == 1) {
        index = i;
      }
    } else if (n > 0) {
      nums[index] = nums[i];
      nums[i] = 0;
      index = index + 1;
    }
  }
}

移动元素

给定一个数组 nums和一个值val，你需要原地移除所有数值等于val的元素，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用O(1)额外空间的条件下完成。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例：

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

复制到原数组定义 nums[0…i] 为非 val 的数列，遍历整个数列不断的维护这个定义

//执行用时 :64 ms, 在所有 javascript 提交中击败了77.37%的用户
//内存消耗 :34.2 MB, 在所有 javascript 提交中击败了5.58%的用户
var removeElement = function (nums, val) {
  let j = 0;
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] != val) {
      nums[j] = nums[i];
      j++;
    }
  }
  return j;
};

切割或添加元素到原数组

//执行用时 :64 ms, 在所有 javascript 提交中击败了77.37%的用户
//内存消耗 :34.4 MB, 在所有 javascript 提交中击败了5.04%的用户
var removeElement = function (nums, val) {
  var lang = nums.length;
  for (var i = 0; i < lang; i++) {
    if (nums[i] == val) {
      nums.splice(i, 1);
      i--;
    }
  }
  return nums.length;
};


//执行用时 :72 ms, 在所有 javascript 提交中击败了37.31%的用户
//内存消耗 :34.4 MB, 在所有 javascript 提交中击败了5.04%的用户
var removeElement = function (nums, val) {
  var len = nums.length;
  for (var i = len; i--;) {
    if (nums[i] !== val) {
      nums.push(nums[i]);   //nums.unshift(nums[i]); i++; j++;
    }
  }
  return nums.splice(0, len).length;
};

删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例：

给定数组 nums = [1,1,2], 

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 

你不需要考虑数组中超出新长度后面的元素。

定义 nums[0…i] 为为非重复数列，遍历整个数列不断的维护这个定义。解题思路与上题类似，判断条件有改变

//执行用时 :76 ms, 在所有 javascript 提交中击败了94.62%的用户
//内存消耗 :37.1 MB, 在所有 javascript 提交中击败了44.02%的用户
var removeDuplicates = function (nums) {
  let j = 0;
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] != nums[i + 1]) {
      nums[j] = nums[i];
      j++;
    }
  }
  return j;
};


//执行用时 :84 ms, 在所有 javascript 提交中击败了77.86%的用户
//内存消耗 :37.1 MB, 在所有 javascript 提交中击败了45.84%的用户
var removeDuplicates = function (nums) {
  let len = nums.length;
  if (len < 2) { return len; }
  let i = 0;
  let j = i + 1;
  while (j <= len - 1) {
    if (nums[j] != nums[i]) {
      if (i + 1 != j) nums[i+1] = nums[j];
      i += 1;
    }
    j += 1;
  }
  return i + 1;
}

删除排序数组中的重复项 II

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例：

给定 nums = [1,1,1,2,2,3],

函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。

你不需要考虑数组中超出新长度后面的元素。

判断左右元素是否相同

//执行用时 :64 ms, 在所有 javascript 提交中击败了99.76%的用户
//内存消耗 :36 MB, 在所有 javascript 提交中击败了35.71%的用户
var removeDuplicates = function (nums) {
  let len = nums.length;
  if (len <= 2) return len;
  let i = 1;
  let j = i - 1;
  let k = i + 1;

  while (k <= len - 1) {
    if (nums[i] != nums[k] || (nums[i] == nums[k] && nums[j] != nums[k])) {
      j = i;
      nums[i + 1] = nums[k];
      i += 1;
    }
    k++;
  }
  return i + 1;
};

//js 两边与中间相等, 则删除中间的
//执行用时 :84 ms, 在所有 javascript 提交中击败了53.28%的用户
//内存消耗 :36 MB, 在所有 javascript 提交中击败了34.28%的用户
var removeDuplicates = function (nums) {
  for (var i = 1; i < nums.length - 1; i++) {
    if (nums[i] == nums[i - 1] && nums[i] == nums[i + 1]) {
      nums.splice(i, 1);
      i--;
    }
  }
};