给定一个排序数组,你需要在原地删除重复出现的元素

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

不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 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。

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

说明:

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

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

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

我的答案:

 
 
class Solution {               
     public:                    
            int removeDuplicates(vector<int>& nums) 
            {       
                int value = 0;     
                int temp = 0; 
                int last_value = 0;
                bool flag = false;  
                if (nums.size() ==1)
                return 1;
                for (int i = 0; i < nums.size(); i++)
                {   
                    if (i == nums.size() - 1)  
                    {
                        
                        //for (int j = 0 ; j < nums.size() - temp-1;j++)
                        //{
                        //    for (vector<int>::iterator it = nums.begin() + temp; it != nums.end();it++)
                        //    {
                        //        nums.erase(it);
                        //        break;                                
                        //    }
                        //}                        
                        if (last_value==nums[i] || last_value ==0 ||value==nums[i])
                        return temp; 
                        else
                        return temp+1;
                    }
                    if (nums[i] == nums[i+1])  
                    {
                        if (!flag && value == nums[i])
                        {
                            temp++;
                        }
                        if (!flag && value != nums[i] && nums[i] != last_value)
                        {
                            nums[temp] = nums[i+1];
                            temp++;
                            
                        }
                        flag = true;
                        value = nums[i+1];
                        
                    }          
                    else       
                    {   //if (i!=0)
                        {
                             if (flag)
                             {
                                 nums[temp] = nums[i+1];
                                  
                             }   
                             else
                             {
                                nums[temp] = nums[i];
                                flag = false; 
                            }
                            last_value = nums[temp];
                            temp++;
                            
                            }                        
                        }          
                }              
                return temp;                                                                                                                                                                     
            }          
};
 
 
 
我里个X,写的代码真狗屎一样,服了自己,要调试才清楚代码的思路;尼玛,赶紧学学大神的代码。
 
 
 
优秀人的解法:
 

class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size()==0) return 0;
int length=1;
int prev=nums[0];
for(int i=1;i<nums.size();i++){
if(nums[i]!=prev){
prev=nums[i];
nums[length++]=nums[i];
}
}
return length;
}

};

作者:rt-huang
链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/onde-jie-fa-zhu-yi-yuan-di-cao-zuo-by-rt-huang/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

解题思路
此处撰写解题思路
使用快慢双指针法 分别定义指针i与指针j,开始两指针都指向num[0],
快指针i向前移动 指向的数组与 慢指针j所知数组比较 num【j】!=num【i】
若相同则快指针向前移动一格,慢指针向前移动一格;若不同,将快指针i指向数组赋值给慢指针j,快慢指针分别向前移动一格;重复操作直到i指针指到末尾。
若数组长度为0则直接return 0;
最后 返回慢指针所指数组长度加一 return j+1。

代码
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int i,j;
int length=nums.size();

if(length==0)//判断数组长度 若为0直接返回
return 0;

for (i=0;i<nums.size();i++)//采用for循环使指针i不停向前移动
{
if(nums[i]!=nums[j])
{
if(i-j>1) //判断快慢指针 若 相邻数组且元素值不同时,虽然也可进行赋值操作,
//但可以省略该赋值操作,避免无意义操作 提高运行效率
{nums[j+1]=nums[i];}
j++;
}

}

return j+1;

}
};

作者:dulai-xue-xi-yi-xia
链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shan-chu-pai-xu-shu-zu-zhong-de-zhong-fu-yuan-su-y/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

解题思路
话不多说

代码
class Solution {
public:
int removeDuplicates(vector<int>& nums)
{
int len = nums.size();
if (len == 0) return 0; //又是这种坑爹情况
int i = 0, j = 0;
while (j < len)
{
if (nums[i] != nums[j])
nums[++i] = nums[j];
j++;
}
return i + 1;
}
};

作者:int-myheart
链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shuang-zhi-zhen-by-int-myheart/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

class Solution {               
     public:                    
            int removeDuplicates(vector<int>& nums) 
            {       

                if( nums.size() == 0) return 0;
                int p = 0;
                int q = 1;
                while(q < nums.size()){
                    if(nums[p] != nums[q]){
                        nums[p + 1] = nums[q];
                        p++;
                    }
                    q++;
                }
                return p + 1;
                                 
            }          
};
 
原文地址:https://www.cnblogs.com/williamwucoder/p/12923888.html