leetcode-26- 删除排序数组中的重复项-java

题目与测试样例

package pid26;
/*26. 删除排序数组中的重复项
题目描述提示帮助提交记录社区讨论阅读解答
随机一题
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 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]);
}*/
public class main {
	
	public static void main(String[] args) {
		int[][] testTable = {{1,1,2},{1,1,2,2,5,6,7,7},{1,2,3,5},{1,1,1,1}};
		for (int[] ito : testTable) {
			test(ito);
		}
	}
		 
	private static void test(int[] ito) {
		Solution solution = new Solution();
		int rtn;
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ito.length; i++) {
		    System.out.print(ito[i]+" ");
		}//开始时打印数组
		rtn = solution.removeDuplicates(ito);//执行程序
		long end = System.currentTimeMillis();		
		System.out.println(ito + ": rtn=" + rtn);
		for (int i = 0; i < rtn; i++) {
		    System.out.print(ito[i]+" ");
		}//打印结果几数组
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解答1（原始，出错）
应该是没有考虑到数组大小为1的情况，导致越界

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
	at Solution.removeDuplicates(Solution.java:4)
	at __DriverSolution__.__helper__(__Driver__.java:8)
	at __Driver__.main(__Driver__.java:52)

package pid26;

public class Solution {

	public int removeDuplicates(int[] nums) {
		int length=1;
		int previous=nums[0];
		for(int i=1;i<nums.length;i++){
			if(nums[i]==previous){
				
			}
			else{
				length++;				
				previous=nums[i];
				nums[length]=previous;
			}
		}
       return length;
    }

}

解答2（出错） 得到数字正确，但是数组不正确，第二个数字重复

public int removeDuplicates(int[] nums) {
		int length=1;
		if(nums.length==1){
			return 1;
		}
		
		int previous=nums[0];
		for(int i=1;i<nums.length;i++){
			if(nums[i]==previous){
				
			}
			else{
				length++;				
				previous=nums[i];
				nums[length]=previous;
			}
		}
       return length;
    }

1 1 2 [I@15db9742: rtn=2
1 1 
耗时：1ms
-------------------
1 1 2 2 5 6 7 7 [I@6d06d69c: rtn=5
1 1 2 5 6 
耗时：0ms
-------------------
1 2 3 5 [I@7852e922: rtn=3
1 2 2 
耗时：0ms
-------------------
1 1 1 1 [I@4e25154f: rtn=1
1 
耗时：1ms
------------

解答3（leetcode出错还是indexoutofbound，自己检验正确）
此时将nums[length-1]=previous;，length改为-1，因为队列的关系，最后一个的index为length-1。
此时将if注释掉还是这样，将length作为solution的变量而不是函数的还是这样

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

解答4（成功 11ms）
此时考虑了数组为空的情况

package pid26;

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

}

解答5（成功，自我优化后结果，10ms）
附思路

public class Solution {
	//计算思路，设置结果length，前一个的数值previous
	//从第二个数组中的数字开始，向最后一个循环
	//如果该数字与previous相同，啥也不干
	//如果不同，长度+1，previous变为当前的数字，数组中的计算的当前不重复的位置为该值。
		
	public int removeDuplicates(int[] nums) {
		int length=1;
		if(nums.length==0){
			return 0;
		}		
		int previous=nums[0];
		for(int i=1;i<nums.length;i++){
			if(nums[i]!=previous){
				length++;				
				previous=nums[i];
				nums[length-1]=previous;
			}			
		}
       return length;
    }

}

解答6 自己的（成功，2ms）
思路基本一致，用index作为标志，记录这次要放入的位置，没有用previous存储前一个的值，直接取值
由于nums里面是排序后的数组，只需与nums[index-1]比较即可
其实可以认为这个方法是双指针
数组完成排序后，我们可以放置两个指针 i 和index，其中i 是慢指针，而 index 是快指针。只要 nums[i]=nums[index-1]，我们就增加i以跳过重复项。
当我们遇到 nums[index-1]≠nums[i]时，跳过重复项的运行已经结束，因此我们必须把它的值复制到 index。然后递增index和i，接着我们将再次重复相同的过程，直到i 到达数组的末尾为止。

public int removeDuplicates(int[] nums) {
		int length=nums.length;
		if(nums.length==0){
			return 0;
		}
		//index是这次放入的位置，由于nums是个排序数组，now只用于index-1的位置比较即可
		int index=1;
		for(int i=1;i<length;i++){
			if(nums[i]!=nums[index-1]){
				nums[index]=nums[i];
				index++;
			}
		}
		return index;
		
    }