如何高效的對有序數組去重

給定一個排序數組，須要在原地刪除重複出現的元素，使得每一個元素只出現一次，返回移除後數組的新長度

數組nums=[0,0,1,1,1,2,2,3,3,4]

函數應該返回新的長度爲5，而且原數組nums的前五個元素被修改成0，1，2,3,4。不要使用額外的數組空間，必須在原地修改輸入數據並在O(1)額外空間的條件下完成

 

分析：

對於問題。若是不要求空間和時間要求的話，仍是很easy的。可是要求O(1)的時間。所以必須得另外想辦法解決。這個的前提是有序數組，所以同樣的數字都是排列在一塊兒的。這裏能夠用到兩個指針位，一個是慢指針，一個是快指針。快指針在慢指針以前，當遇到重複的數字的時候，快指針一直往前移動，當遇到和慢指針不相同的數字的時候，慢指針移動，並用快指針的值來替代此時慢指針的值。最終slow指針以前的值都是不重複的，以後的都是重複的值。

以下示例：s表明慢指針，F快指針

0      0      1      1      1      2      2      3      3      4

S      F

 

1 num[s] == num[f]. F指針向前移動

 

0      0      1      1      1      2      2      3      3      4

S              F

 

2 num[s] != num[f]. S指針向前移動，而且num[s]=num[f]. F指針繼續向前移動

 

0      1      1      1      1      2      2      3      3      4

　　S              F

 

3 num[s] == num[f]. F指針向前移動

 

0      1      1      1      1      2      2      3      3      4

　　S                      F

 

4 num[s] == num[f]. F指針向前移動

 

0      1      1      1      1      2      2      3      3      4

　　S                              F

5 num[s] != num[f]. S指針向前移動，而且num[s]=num[f]. F指針繼續向前移動

 

0      1      2      1      1      2      2      3      3      4

　　　　S                              F

6 num[s] == num[f]. F指針向前移動

 

 

0      1      2      1      1      2      2      3      3      4

　　　　S                                      F

7 num[s] != num[f]. S指針向前移動，而且num[s]=num[f]. F指針繼續向前移動

 

0      1      2      3      1      2      2      3      3      4

　　　　　　  S                                      F

8 num[s] == num[f]. F指針向前移動

 

0      1      2      3      1      2      2      3      3      4

　　　　　　  S                                              F

9 num[s] != num[f]. S指針向前移動，而且num[s]=num[f]. F指針繼續向前移動

 

此時s指針以前的數組就是不重複的數組

0      1      2      3      4      2      2      3      3      4

　　　　　　　　　S          

代碼以下：

int removeDuplicates(int num[], int len)
{
    int slow, fast;
    slow = 0;
    fast = 1;
    while (fast < len)
    {
        if (num[fast] != num[slow])
        {
            slow++;
            num[slow] = num[fast];
        }
        fast++;
    }
    return slow+1;
}