如何高效的对有序数组去重

给定一个排序数组，须要在原地删除重复出现的元素，使得每一个元素只出现一次，返回移除后数组的新长度

数组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;
}