題目與測試樣例

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 [[email protected]: rtn=2
1 1 
耗時：1ms
-------------------
1 1 2 2 5 6 7 7 [[email protected]: rtn=5
1 1 2 5 6 
耗時：0ms
-------------------
1 2 3 5 [[email protected]: rtn=3
1 2 2 
耗時：0ms
-------------------
1 1 1 1 [[email protected]: 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 別人的（成功）
思路基本一致，沒有用previous儲存前一個的值，直接取值

public int removeDuplicates(int[] nums) {
         if (nums.length == 0)
            return 0;
        //判斷無輸入
        int number = 0;//標記計數
        for (int i=0; i < nums.length ; i++) {
            if ( nums[i] != nums[number] ) {
                number++;
                nums[number] = nums[i];
            }
        }
        number+=1; //標記+1即為數字個數
        return number;

    }