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

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

數組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;
}