leetcode算法刷题记录之删除排序数组中的重复项

题目描述：

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

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

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

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

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

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

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

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

题解：

解题思路一：

* 1.主要思路快慢指针，快指针负责遍历数组，慢指针走过位置，都是不重复的元素。

* 2.我们需要用到2个指针：

* index(慢指针)

* i (快指针，用以遍历数组)

* 3.当nums[i] == nums[index],快指针继续走，

* 直到找到nums[i] != nums[index]的元素nums[i],慢指针前走一步后，当前慢指针项的值更新为nums[i]。

 /**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    var n = nums.length;
    if(n==0||n == 1){
        return n;
    }
    var index = 0;
    for(var i=1;i<n;i++){
        if(nums[i] != nums[index]){
            index++;
            nums[index] =  nums[i];
        }
    }
    return index+1;
};

题目描述：如果每个元素可以出现K次呢？比如K=2呢?

/**
 * 删除排序数组中的重复项
 * 给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。
 * 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
 * 
 * 示例1：
 *  输入：nums = [1,1,1,2,2,3]
 *  输出：5, nums = [1,1,2,2,3]
 *  解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
 * 
 * 解题思路一：
 *   1.主要思路快慢指针，快指针负责遍历数组，慢指针走过位置，都是符合条件的元素。
 *   2.我们需要用到2个指针：
 *     index(慢指针)
 *     i (快指针，用以遍历数组)
 *   3.指针移动条件：
 *     假设每个元素 最多出现K次
 *     直到找到nums[i] != nums[index-K+1]的元素nums[i],慢指针前走一步后，当前慢指针项的值更新为nums[i]。
 * 
 * 解题思路二：
 *   1.主要思路快慢指针，快指针负责遍历数组，慢指针走过位置，都是符合条件的元素。
 *   2.我们需要用到2个指针+1个计数：
 *     index(慢指针)
 *     i (快指针，用以遍历数组)
 *     flag 初始值为0
 *   3.逻辑：
 *     nums[i] == nums[index]，flag++;
 *     nums[i] != nums[index] ，
 *          (1)下标大于index小于i的那些相等的值，只要大于等于1，慢指针移动一步，更新慢指针的最后一位的值为nums[i-1]；
 *          (2)处理nums[index],重置flag=0,更新当前慢指针最后一位为nums[i]
 *     通过上面逻辑我们可以看出，更新慢指针的操作都是在碰到不相等的值的时候 才会去处理之前相等的时候的情况，
 *     这样如果nums最后几位是相等的，那就会漏处理，所以在遍历完成后，还需要根据flag的值对应处理一次慢指针的更新
 * 
 */

/**
 * @param {number[]} nums
 * @return {number}
 */
// 思路一
// var removeDuplicates = function(nums) {
//     var n = nums.length;
//     if(n<2){
//         return n;
//     }
//     var i = 2,index = i-1;
//     for(i=2;i<n;i++){
//         if(nums[i]!=nums[index-2+1]){
//             index++;
//             nums[index] = nums[i];
//         }
//     }
//     return index+1;
// };
// 思路二
var removeDuplicates = function(nums) {
    var n = nums.length;
    if(n<2){
        return n;
    }
    var index=0,flag = 0;
    for(var i=1;i<n;i++){
        if(nums[i] == nums[index]){
            flag++;
        }else{
            if(flag>=1){
                index++;
                nums[index] = nums[i-1];
            }
            flag=0;
            index++;
            nums[index] = nums[i];
        }
    }
    if(flag>=1){
        index++;
        nums[index] = nums[n-1];
    }
    return index+1;
};

var nums = [0,0,1,1,1,1,2,3,3];
var length = removeDuplicates(nums);
console.log(length,nums);