[已解决]力扣总是报错访问越界怎么办？我在本地电脑的编译器上运行没有问题啊

Dogelike

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

给你一个 升序排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

判题标准:

系统会用下面的代码来测试你的题解:

1. 
   
2. int[] nums = [...]; // 输入数组
   
3. int[] expectedNums = [...]; // 长度正确的期望答案
   
4. 
   
5. int k = removeDuplicates(nums); // 调用
   
6. 
   
7. assert k == expectedNums.length;
   
8. for (int i = 0; i < k; i++) {
   
9.     assert nums[i] == expectedNums[i];
   
10. }
    

复制代码

如果所有断言都通过，那么您的题解将被通过。


示例 1：

输入：nums = [1,1,2]
输出：2, nums = [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]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。


提示：

1 <= nums.length <= 3 * 104
-104 <= nums <= 104
nums 已按 升序 排列

以下是本人的C++代码：

1. 
   
2. class Solution {
   
3. public:
   
4.     int removeDuplicates(vector<int>& nums) {
   
5.         if(nums.size() == 1)
   
6.             return 1;
   
7.         if(nums[0] == nums[nums.size()-1]){
   
8.             return 1;
   
9.         }
   
10. 
    
11.         int i = 0, j;
    
12.         int k = nums.size();
    
13.         while(i < k-1){
    
14.             if(nums[i+1] == nums[i]){
    
15.                 j = i+1;
    
16.                 while(nums[j] == nums[i])
    
17.                     j++;
    
18.                 if(j >= k){
    
19.                     j = k;
    
20.                     k -= j - i - 1;
    
21.                     nums.erase(nums.begin()+i+1, nums.end());
    
22.                     return k;
    
23.                 }
    
24.                 k -= j - i - 1;
    
25.                 nums.erase(nums.begin()+i+1, nums.begin()+j);
    
26.             }
    
27.             i++;
    
28.         }
    
29.         return k;
    
30.     }
    
31. };
    

复制代码

求高人指点，快被这么一个简单题逼疯了

最佳答案

月排行榜 / 总排行榜

学习编程中的Ben

2023-8-15 20:36:46

你好！根据你提供的问题和代码，我看到你想要实现删除有序数组中的重复项，并返回新数组的长度。下面是对你代码的一些建议和修改：

首先，你可以优化你的代码逻辑。在当前的实现中，你使用了双指针的方法来遍历数组并删除重复元素。然而，这种做法并不高效，因为在删除元素时需要移动数组的元素，导致时间复杂度为O(n^2)。实际上，你可以通过一个快指针和一个慢指针来实现，只需遍历一次数组即可完成任务。

下面是修改后的代码：

1. class Solution {
2. public:
3.     int removeDuplicates(vector<int>& nums) {
4.         if (nums.empty()) {
5.             return 0;
6.         }
8.         int slow = 0;
9.         for (int fast = 1; fast < nums.size(); fast++) {
10.             if (nums[fast] != nums[slow]) {
11.                 slow++;
12.                 nums[slow] = nums[fast];
13.             }
14.         }
16.         return slow + 1;
17.     }
18. };

复制代码

接下来是对你的代码进行一些讲解：

1. 首先，我们检查输入数组是否为空，如果为空则直接返回0。
2. 我们定义两个指针：slow和fast。slow指向当前已处理的不重复元素的位置，而fast用于遍历整个数组。
3. 我们从数组的第二个元素开始遍历，如果nums[fast]与nums[slow]不相等，则将nums[fast]赋值给nums[slow+1]，同时将slow指针后移一位。
4. 最后返回slow + 1，即为新数组的长度。

希望这些修改能够解决你的问题！如果你还有其他疑问，请随时提出。

如果回答对你有帮助，请给我一个最佳答案！

跳转到最佳答案楼层

isdkz

问题出在你的代码中的两个地方。首先，你在判断数组中是否只有一个元素时，使用了 nums[0] == nums[nums.size()-1] 的条件。这是不正确的，因为题目要求的是删除重复元素，而不是判断数组中是否只有一个元素。正确的判断条件应该是 nums.size() == 1 。

其次，你在删除重复元素时，使用了 nums.erase(nums.begin()+i+1, nums.end()) 的方式。这是不正确的，因为你在遍历数组时，使用了 i++ 来移动指针，而删除元素后，指针的位置也会发生变化。正确的删除方式应该是使用 nums.erase(nums.begin()+i+1, nums.begin()+j) 。

以下是修正后的代码：

1. class Solution {
   
2. public:
   
3.     int removeDuplicates(vector<int>& nums) {
   
4.         if(nums.size() == 1)
   
5.             return 1;
   
6.         
   
7.         int i = 0, j;
   
8.         int k = nums.size();
   
9.         while(i < k-1){
   
10.             if(nums[i+1] == nums[ i]){
    
11.                 j = i+1;
    
12.                 while(nums[j] == nums[ i])
    
13.                     j++;
    
14.                
    
15.                 if(j >= k){
    
16.                     j = k;
    
17.                     k -= j - i - 1;
    
18.                     nums.erase(nums.begin()+i+1, nums.end());
    
19.                     return k;
    
20.                 }
    
21.                
    
22.                 k -= j - i - 1;
    
23.                 nums.erase(nums.begin()+i+1, nums.begin()+j);
    
24.             }
    
25.             i++;
    
26.         }
    
27.         
    
28.         return k;
    
29.     }
    
30. };
    

复制代码

希望能帮到你！如果还有其他问题，请随时提问。

学习编程中的Ben

你好！根据你提供的问题和代码，我看到你想要实现删除有序数组中的重复项，并返回新数组的长度。下面是对你代码的一些建议和修改：

首先，你可以优化你的代码逻辑。在当前的实现中，你使用了双指针的方法来遍历数组并删除重复元素。然而，这种做法并不高效，因为在删除元素时需要移动数组的元素，导致时间复杂度为O(n^2)。实际上，你可以通过一个快指针和一个慢指针来实现，只需遍历一次数组即可完成任务。

下面是修改后的代码：

1. class Solution {
2. public:
3.     int removeDuplicates(vector<int>& nums) {
4.         if (nums.empty()) {
5.             return 0;
6.         }
8.         int slow = 0;
9.         for (int fast = 1; fast < nums.size(); fast++) {
10.             if (nums[fast] != nums[slow]) {
11.                 slow++;
12.                 nums[slow] = nums[fast];
13.             }
14.         }
16.         return slow + 1;
17.     }
18. };

复制代码

接下来是对你的代码进行一些讲解：

1. 首先，我们检查输入数组是否为空，如果为空则直接返回0。
2. 我们定义两个指针：slow和fast。slow指向当前已处理的不重复元素的位置，而fast用于遍历整个数组。
3. 我们从数组的第二个元素开始遍历，如果nums[fast]与nums[slow]不相等，则将nums[fast]赋值给nums[slow+1]，同时将slow指针后移一位。
4. 最后返回slow + 1，即为新数组的长度。

希望这些修改能够解决你的问题！如果你还有其他疑问，请随时提出。

如果回答对你有帮助，请给我一个最佳答案！

Dogelike

isdkz 发表于 2023-8-15 20:36
问题出在你的代码中的两个地方。首先，你在判断数组中是否只有一个元素时，使用了 nums[0] == nums[nums.si ...

不对，哥们，nums[0] == nums[nums.size()-1] 是用来判断数组中是否只有一种数字的，因为给的数组都是升序排好的。nums.erase(nums.begin()+i+1, nums.end()) 是当j越界，就是i后面一直到末尾都是重复元素时用的，你再看看

Dogelike

学习编程中的Ben 发表于 2023-8-15 20:36
你好！根据你提供的问题和代码，我看到你想要实现删除有序数组中的重复项，并返回新数组的长度。下面是对你 ...

这个方法确实很好

学习编程中的Ben

Dogelike 发表于 2023-8-15 20:44
这个方法确实很好

最佳可以给我吗?

Dogelike

学习编程中的Ben 发表于 2023-8-15 20:45
最佳可以给我吗?

给了

学习编程中的Ben

Dogelike 发表于 2023-8-15 20:51
给了

谢谢