【作业1】LeetCode 26. 删除有序数组中的重复项-跟着帅地玩副业，开拓第二曲线PlayOffer

幽小皮永久会员 2024年3月29日下午8:30

count表示不重复的数字个数-1

class Solution {
public int removeDuplicates(int[] nums) {
if(nums null || nums.length < 1){
return 0;
}
if(nums.length 1){
return 1;
}
int l = 0;
int r = 1;
int count = 1;
while(r <= nums.length – 1){
if(nums[l] nums[r]){
r++;
}else{
nums[count] = nums[r];
count++;
l = r;
r++;
}
}
return count;
}
}
“`java

0 赞同 0 条回复

塔底的仰望永久会员 2023年10月12日下午8:32

len指向当前的无重复数组的最后一个元素

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 1) {
            return 1;
        }

        int len = 0;
        for (int i = 1; i < nums.length; i++) {
            if (nums[len] != nums[i]) {
                nums[++len] = nums[i];
            }
        }

        return len + 1;

    }
}

0 赞同 0 条回复

DataSpace 普通 2023年9月25日下午2:50

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if nums is None or len(nums)<1:
            return 0
        i,j = 0,1
        while j<=len(nums)-1:
            if nums[i] == nums[j]: #不做操作j后移
                j = j + 1
            else:#i增加 同时把nums[j] 换到nums[i]处 这样i之前是处理好的
                i = i + 1
                nums[i] = nums[j]                
                j = j + 1
        return i+1

0 赞同 0 条回复

Thaddeus 永久会员 2023年8月24日下午3:00

打卡

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

0 赞同 0 条回复

泡芙永久会员 2023年8月24日下午2:28

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int l = 0;
        int r = 1;
        while(r <= nums.length - 1){
            if(nums[l] != nums[r]){
                // 如果不等，先移动再交换
                l ++;
                nums[l] = nums[r];
            } else {
                r ++;
            }
        }
        return l + 1;
    }
}

0 赞同 0 条回复

阿尚普通 2023年8月16日上午10:30

//移除元素变形：注意慢指针的移动条件
//当num[i]==nums[i - 1]时快指针i直接跳过
class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0) return 0;

        int j = 0;
        for(int i = 0; i < nums.length; i++){
            if(i == 0 || nums[i] != nums[i - 1]){
                nums[j] = nums[i];
                j++;
            }
        }

        return j;
    }
}

0 赞同 0 条回复

𬍤永久会员 2023年7月26日下午12:41

打卡
class Solution {
public int removeDuplicates(int[] nums) {
if(nums null || nums.length < 1){
return 0;
}
int l = 0;
int r = 1;
while(r < nums.length){
if(nums[l] nums[r]){
r++;
}else{
l++;
nums[l] = nums[r];
r++;
}
}
return l+1;
}
}

0 赞同 0 条回复

CrazyJavaBoy 永久会员 2023年7月23日下午5:04

时间复杂度O(n) 空间复杂度O(1) 原地比较与替换

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0) {
            return 0;
        }
        int index = 0;
        for(int i = 1; i < nums.length; i++) {
            if(nums[i] != nums[index]) {
                nums[index+1] = nums[i];
                index++;
            }
        }
        return index+1;
    }
}

0 赞同 0 条回复

3_🔥 永久会员 2023年7月9日下午3:03

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length == 0 || nums == null) return 0;
        if(nums.length == 1) return 1;
        int s = 1,f = 1;
        while (f<nums.length){
            if (nums[f] != nums[f-1]) {
                nums[s] = nums[f];
                s++;
            }
            f++;
        }
        return s;
    }
}

快慢指针，一开始都在下标为1处，交换的条件是f的值和f-1不一样，交换完s++

1 赞同 0 条回复

Zn_XiangR 永久会员 2023年6月10日下午11:04

打卡
class Solution { public int removeDuplicates(int[] nums) { int left = 0; int right = 0; while (left <= right && right < nums.length) { if (nums[left] == nums[right]) { right++; } else { nums[++left] = nums[right]; } } return left + 1; } }

0 赞同 0 条回复

mpweixin用户普通 2023年6月2日下午5:06

打卡

class Solution {
    public int removeDuplicates(int[] nums) {
        int l = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[l] != nums[i]){
                if(i - l > 1){
                    l++;
                    nums[l] = nums[i]; 
                }else{
                    l++;
                }
            }
        }
        return l + 1;
    }
}

0 赞同 0 条回复

KEV 永久会员 2023年5月31日下午10:10

C++代码，用cnt记录多余的元素，依次遍历数组，判断当前元素、或者移动cnt个位置。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty()){
            return 0;
        }
        if(nums.size()==1){
            return 1;
        }
        int cnt=0;
        // int i=1,j=nums.size()-1;
        for(int i=1;i<nums.size();i++){
            if(nums[i-1]==nums[i]){
                cnt++;
            }else{
                nums[i-cnt]=nums[i];
            }
        }
        return nums.size()-cnt;
    }
};

0 赞同 0 条回复

mpweixin用户永久会员 2023年5月14日下午12:59

作业打卡

class Solution {
    public int removeDuplicates(int[] nums) {
        int len = 1;

        for(int i = 1;i < nums.length;i++){
            if(nums[i] == nums[len - 1]){

            }else{
                nums[len] = nums[i];
                len++;
            }
        }

        return len;
    }
}

1 赞同 0 条回复

路易十二👑 普通 2023年5月10日上午10:07

简化版双指针

function removeDuplicates(nums: number[]): number {
    let length = 0, curr = -101;
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] > curr) {
            curr = nums[i];
            nums[length++] = curr;
        }
    }
    return length;
};

0 赞同 0 条回复

LicodeCO.LTDao 普通 2023年5月5日下午12:10

时间复杂度O(n)

function removeDuplicates(nums: number[]): number {
    if (nums === null || nums.length < 1) return 0

    // 定义慢指针，指向第一个元素
    let p1 = 0

    // 定义快指针，指向第二个元素
    let p2 = 1

    // 终止条件：p2 > nums.length
    while(p2 < nums.length) {
        if (nums[p1] !== nums[p2]) {
            p1++
            nums[p1] = nums[p2]
        }
        p2++
    }

    return p1+1
};

0 赞同 0 条回复

Violet 永久会员 2023年4月19日上午11:11

时间O(n) 空间O(1)

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return 1;
        }
        int fast = 1, slow = 1;
        while (fast < nums.length) {
            if (nums[fast] == nums[fast - 1]) {
                fast++;
            } else {
                nums[slow++] = nums[fast++]; 
            }
        }
        return slow;
    }
}

0 赞同 0 条回复

席永久会员 2023年4月17日下午4:34

public static int DelRepeatElement(int[] arr) {
        int lowindex = 0;
        int fastindex = 1;
        if (arr==null){
            return -1;
        }
        while (fastindex<arr.length){  //快慢指针优先使用while循环即可
            if (arr[lowindex] == arr[fastindex]){   //如果fastindex的值和前面的值相等， 就让fastindex++向后移动
                fastindex++;
            }else {
                arr[++lowindex] =arr[fastindex]; //如果不相等，就把fastindex的值赋值给lowindex+1的位置
                fastindex++;   //然后fastindex继续向后移动即可
            }
        }
        return lowindex+1;
    }

0 赞同 0 条回复

小趴菜永久会员 2023年4月12日上午10:48

时间复杂度O（n）空间O（1）
class Solution {
public int removeDuplicates(int[] nums) {
if(nums.length 0){
return 0;
}
int slow = 0;
int fast = 0;
while(fast<nums.length){
if(nums[slow]!=nums[fast]){
slow++;
nums[slow] = nums[fast];
}
fast++;
}
return slow + 1;
}
}

0 赞同 0 条回复

sasuke 普通 2023年4月11日下午5:59

class Solution(object):
    def removeDuplicates(self, nums):
        #时间复杂度O(n),空间复杂度O(1)
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:
            return 0;
        lens=len(nums)
        fast=slow=1
        while fast<lens:
            if(nums[fast]!=nums[fast-1]):
                nums[slow]=nums[fast]
                slow+=1
            fast+=1
        return slow

0 赞同 0 条回复

mpweixin用户永久会员 2023年4月9日下午5:40

//时间复杂度O(n), 空间复杂度O(1)
class Solution {
    public int removeDuplicates(int[] nums) {
        int length = 1;
        for(int i = 1; i<nums.length; i++){
            if(nums[i]==nums[i-1]) continue;
            nums[length++] = nums[i]; 
        }
        return length;
    }
}

0 赞同 0 条回复

Only You!(^-^(^-^)) 永久会员 2023年4月9日下午5:32

public class Solution {
    /*采用双指针*/
    /*时间复杂度：O(n)。 空间复杂度：O(1)*/
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0) return 0;
        int p = 0, q = 1;
        while (q < nums.length) {
             if(nums[q] != nums[p]) {
                nums[p + 1] = nums[q];
                p++;
             }
            q++;
        }
        return p + 1;
    }

    public static void main(String[] args) {
        int[] a = {0,0,1,1,1,2,2,3,3,4};
        Solution solution = new Solution();
        int len = solution.removeDuplicates(a);
        for (int i = 0; i < len; i++){
            System.out.println(a[i]);
        }
    }
}

1 赞同 0 条回复

庄重普通 2023年4月8日下午7:11

// 想到是前后对比，但是最后思路混杂，看了题解
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {

        if(nums.empty()) return 0;

        int l = 0;
        int r = 1;

        while(r < nums.size()) {

            if(nums[l] == nums[r]) {
                r ++;
            } else {
                nums[l+1] = nums[r];
                l ++;
            }
        }
        return l+1;
    }
};

0 赞同 0 条回复

Yangon 普通 2023年4月8日下午4:35

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length < 1){
            return 0;
        }
        int f = 1 , s = 0;
        while(f < nums.length){
            if(nums[s] != nums[f]){
                nums[s+1] = nums[f];
                s++;
            }
                f++;           
        }
        return s+1;
    }
}

0 赞同 0 条回复

秊永久会员 2023年4月7日下午1:28

    public int removeDuplicates(int[] nums) {
        if (nums.length == 1) return 1;
        int l = 0;
        int r = 0;

        while (r < nums.length) {
            if (nums[l] < nums[r]) {
                nums[l + 1] = nums[r];
                ++l;
                ++r;
            } else if (nums[l] == nums[r]) {
                while (r < nums.length && nums[l] == nums[r]) {
                    ++r;
                    if (r == nums.length) return l + 1;
                }
                nums[l + 1] = nums[r];
                ++l;
                ++r;
            } else {
                // 不可能
            }
        }

        return l + 1;
    }

可简化为：

    public int removeDuplicates(int[] nums) {
        if (nums.length == 1) return 1;
        int l = 0;
        int r = 0;

        while (r < nums.length) {
            if (nums[l] == nums[r]) {
                while (r < nums.length && nums[l] == nums[r]) {
                    ++r;
                    if (r == nums.length) return l + 1;
                }
            } 

            nums[l + 1] = nums[r];
            ++l;
            ++r;
        }

        return l + 1;
    }

0 赞同 0 条回复

溴麝香草酚蓝普通 2023年4月7日上午11:11

class Solution {
    public int removeDuplicates(int[] nums) {
        int length = nums.length;
        if (length == 0) return 0;
        if (length == 1 || nums[0] == nums[length - 1]) return 1;
        int singlePtr = 1;
        for (int i = 1; i < length; i++) {
            if (nums[i] != nums[i - 1]) {
                nums[singlePtr] = nums[i];
                singlePtr++;
            }
        }
        return singlePtr;
    }
}

双指针分别指示当前位置和数值交换位置

0 赞同 0 条回复

易水寒永久会员 2023年4月6日下午6:26

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length == 1) {
            return 1;
        }
        int s = 0, f = 1;
        while(f < nums.length) {
            if(nums[f] == nums[s]) {
                f++;
            }
            else {
                nums[++s] = nums[f];
            }
        }
        return s + 1;
    }
}

//双指针

0 赞同 0 条回复

是梦终空永久会员 2023年4月6日下午5:59

双指针时间复杂度O(n)

class Solution {
    public int removeDuplicates(int[] nums) {
        int l =1;int r = 1;
        while(l<=r && r< nums.length){
            if(nums[r] != nums[r-1]){
                nums[l] = nums[r];
                l++;
            }
            r++;
        }
        return l;
    }
}

0 赞同 0 条回复

Bryce 普通 2023年4月6日上午12:19

双指针加亦或操作

func removeDuplicates(nums []int) int {
    if nums == nil || len(nums) < 1 {
        return 0
    }
    if len(nums) == 1 {
        return 1
    }

    p1 := 0
    p2 := 1
    for p2 < len(nums) &&nums[p1] <= nums[p2] {
        if nums[p1]^nums[p2] == 0 {
            p2++
        }else {
            p1++
            nums[p1] = 0^nums[p2]
        }
    }
    return p1+1
}

0 赞同 0 条回复

小肸永久会员 2023年4月5日下午8:54

快慢指针

class Solution {
    public int removeDuplicates(int[] nums) {
        int slow = 1, fast = 1;
        while (fast < nums.length) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow++] = nums[fast];
            }
            fast ++;
        }
        return slow;
    }
}

1 赞同 0 条回复

有去过的人普通 2023年4月5日下午8:28

下面是代码

class Solution {
    public int removeDuplicates(int[] nums) {
      int l=0;
      for(int r=1;r<nums.length;r++) {
          if(nums[r]!=nums[l]) {
              l++;
          }
          nums[l]=nums[r];
      }
      return l+1;
    }
}

0 赞同 0 条回复

Everglow 永久会员 2023年4月5日下午7:03

class Solution {
    public int removeDuplicates(int[] nums) {
        int slow = 0;
        int fast = 1;
        // [0, slow]范围内是去重后的数组
        // fast指向的是待处理的位置
        while(fast < nums.length) {
            if(nums[fast] == nums[slow]) {
                fast++;
            } else {
                nums[++slow] = nums[fast];
                fast++;
            }
        }
        return slow + 1;
    }
}

0 赞同 0 条回复

宁永久会员 2023年4月5日下午5:24

class Solution {
    public int removeDuplicates(int[] nums) {     
        //快慢指针 快指针和前一个相同，则移动，不相同，则慢指针赋值移动
        int left = 1;
        for(int right = 1; right < nums.length; right++){
            if(nums[right] != nums[right - 1]){
                nums[left] = nums[right];
                left++;
            }
        }
        return left;
    }
}

0 赞同 0 条回复

菜心永久会员 2023年4月5日下午4:58

class Solution {
    public int removeDuplicates(int[] nums) {//快慢双指针
        int slow = 0;
        int quick = 1;
        int n = nums.length;
        while(quick < n) {
            if(nums[slow] == nums[quick]) {
                quick++;
            } else {
                nums[slow + 1] = nums[quick];
                slow++;
            }
        }
        return slow + 1;
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年4月5日下午3:51

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums==null||nums.length<1)
        return 0;
        int pre =0;
        int after=1;
        while(after<=nums.length-1){
            if(nums[pre]==nums[after])
             after++;
            else {
                nums[++pre]=nums[after++];

            }
        }
        return pre+1;//这里必须得+1
    }
}

0 赞同 0 条回复

C++小将永久会员 2023年4月5日下午2:11

作业一打卡

class Solution {
public:
    int removeDuplicates(vector& nums) {
        int slowIndex = 1, fastIndex = 1;
        while(fastIndex < nums.size()){
            if(nums[fastIndex] != nums[fastIndex - 1]){
                nums[slowIndex ++] = nums[fastIndex];
            }
            ++fastIndex;
        }
        return slowIndex;
    }
};

1 赞同 0 条回复

【作业1】LeetCode 26. 删除有序数组中的重复项

共以下 35 个回答

作业一打卡

# 回答此问题取消回复

【作业1】LeetCode 26. 删除有序数组中的重复项

共以下 35 个回答

作业一打卡

# 回答此问题 取消回复

# 回答此问题取消回复