26. 删除有序数组中的重复项

本人代码：

1.C： 

int removeDuplicates(int* nums, int numsSize)
{
    if (numsSize == 0)     //考虑特殊情况
    {
        return 0;
    }

    int count = 0;
    int fast = 0;     //使用快慢指针法
    int slow = 0;
    int dest = 0;

    for (int i = 0; i < numsSize; i++)
    {
        if (nums[slow] != nums[fast])
        {
            nums[dest] = nums[slow];
            ++dest;
            slow = fast;
            ++fast;
            ++count;
        }
        else
        {
            ++fast;
        }
    }

    nums[dest] = nums[slow];
    ++count;

    return count;
}

2.Java： 

class Solution {
    public int removeDuplicates(int[] nums) {     //使用快慢指针思路
        int fast = 0;
        int slow = 0;
        int count = 0;     //计数器，返回长度
        int dest = 0;

        while (fast < nums.length) {
             if (nums[fast] != nums[slow]) {
                nums[dest] = nums[slow];
                ++dest;
                ++count;
                slow = fast;
            } else {
                ++fast;
            }
        }

        nums[dest] = nums[slow];
        ++count;

        return count;
    }
}

3.C++:

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        // 快慢指针法
        int fast = 1;
        int slow = 0;
        int count = 1;

        while (fast < nums.size())
        {
            if (nums[slow] != nums[fast])
            {
                nums[++slow] = nums[fast++];
                ++count;
            }
            else
            {
                ++fast;
            }
        }
        return count;
    }
};

 答案代码：

/*
   注意：C答案在前，Java答案在后
*/
 
/////////////// C 答案 ///////////////////////////
/*
     解题思路：
       1. 设置一个计数，记录从前往后遍历时遇到的不同元素的个数
          由于不同的元素需要往前搬移，那count-1就是前面不同元素
          搬移之后，最后一个元素的位置，下一次在遇到不同元素就应该
          搬移到count位置
       2. 遍历数组，如果nums[i]与nums[count-1]不等，就将nums[i]搬移
          到nums[count]位置，不同元素多了一个，给count++
       3. 循环结束后，返回count
*/
 
int removeDuplicates(int* nums, int numsSize){
    int count = 0;
    for(int i = 1; i < numsSize; ++i)
    {
        if(nums[i] != nums[count])
            nums[++count] = nums[i];
    }
 
 
    ++count;
    return count;
}
 
/////////////// Java 答案 ///////////////////////////
/*
     解题思路：
       1. 设置一个计数，记录从前往后遍历时遇到的不同元素的个数
          由于不同的元素需要往前搬移，那count-1就是前面不同元素
          搬移之后，最后一个元素的位置，下一次在遇到不同元素就应该
          搬移到count位置
       2. 遍历数组，如果nums[i]与nums[count-1]不等，就将nums[i]搬移
          到nums[count]位置，不同元素多了一个，给count++
       3. 循环结束后，返回count
*/
 
class Solution {
    public int removeDuplicates(int[] nums) {
        int count = 1;   // 标记从前往后遍历时，遇到的不同元素的个数
        for(int i = 1; i < nums.length; ++i){
            // 注意：count是从前往后遍历时遇到的不同元素的个数
            //       count-1就是i位置之前最后一个不同元素的位置
            // 因此需要将num[i]搬移到nums[count]处
            if(nums[count-1] != nums[i]){
                nums[count++] = nums[i];
            }
        }
 
        return count;
    }
}

3.C++:

/*方法一:使用erase删除重复数据，不过会导致数据挪动，时间复杂度为O(N*N)
*思路：
* 1. 由于数据是排序好的，通过查询每一个数据的重复区间
* 2. 将重复区间进行删除，只保留一个数据即可
*/
class Solution {
public:
  int removeDuplicates(vector<int>& nums) 
  {
    if(nums.size() == 1)
      return 1;
    vector<int>::iterator it = nums.begin();
    vector<int>::iterator it1 = it;
    it1++;

    while(it != nums.end())
    {
      while(it1!=nums.end() && *it1==*it)
        it1++;
      it = nums.erase(++it, it1);
      it1 = it;
      it1++;
    }
    return nums.size();
  }
};

/*方二:时间复杂度为O(N)
*思路：
* 1. 由于数据是排序好的，通过查询每一个数据的重复区间
* 2. 将重复区间进行删除，只保留一个数据即可
*/
int removeDuplicates(int* nums, int numsSize)
{
  int src1 = 0, src2 = 1;
  int dst = 0;
  // 跟上题的思路一致，相同的数只保留一个，依次往前放
  while(src2 < numsSize)
  {
    nums[dst] = nums[src1];
    ++dst;
		//如果两个指针指向的元素不重复，则指针同时向后移动
    if(nums[src1] != nums[src2])
    {
      ++src1;
      ++src2;
    }
    else
    {
      //如果重复，找到第一个不重复的元素
      while(src2 < numsSize && nums[src1] == nums[src2])
      {
        ++src2;
      }
      //更新指针
      src1 = src2;
      ++src2;
    }
  }
  if(src1 < numsSize)
  {
      nums[dst] = nums[src1];
      ++dst;
  }
  return dst;