去重函数unique，sort，erase的应用

std::unique

一.总述

　　unique函数属于STL中比较常用函数，它的功能是元素去重。即”删除”序列中所有相邻的重复元素(只保留一个)。此处的删除，并不

是真的删除，而是指重复元素的位置被不重复的元素给占领了。由于它”删除”的是相邻的重复元素，所以在使用unique函数之前，一般都

会将目标序列进行排序。

功能：对有序的容器重新排列，将第一次出现的元素从前往后排，其他重复出现的元素依次排在后面

二.函数原型

unique函数的函数原型如下：1.只有两个参数，且参数类型都是迭代器：

iterator unique(iterator it_1,iterator it_2);           

这种类型的unique函数是我们最常用的形式。其中这两个参数表示对容器中[it_1，it_2)范围的元素进行去重(注：区间是前闭后开，即不包含it_2所指的元素),返回值是一个迭代器，它指向的是去重后容器中不重复序列的最后一个元素的下一个元素。

有序的容器：

1

1

2

3

3

4

4

4

5

6

unique处理过的容器：

unique	unique	unique	unique	unique	unique	迭代器指向的地址
1	2	3	4	5	6	1	3	4	4

三、去重函数

unique

头文件：

#include <algorithm>

unique

的作用就是

"去除"

数组中重复的元素，unique去重的过程是将重复的元素移到容器的后面去，实际上这种说法并不正确，应该是把不重复的元素移到前面来：

 
 #include <iostream>       
      
 #include <algorithm>       
          
 using namespace std;       
          
 int main()       
      
 {       
      
 int a[10] = { 0, 7, 7, 6, 1, 1, 5, 5, 8, 9 };       
          
 int n = unique(a, a + 10) - a;       
          
 cout << n << endl;  //7，得到不重复元素的个数；       
          
 for (int i = 0; i < 10; i++)       
      
 cout << a[i] << " ";  //0 7 6 1 5 8 9 5 8 9       
          
 return 0;       
      
 }       
     
         

可以看见最后三个元素是：

5 8 9

，而重复的数字是

1 5 7

，所以网上这种说法：“unique去重的过程是将重复的元素移到容器的后面去”

是不对的

。 

上面的

n

返回的是

7

，它就是：

最后一个不重复数字的下标

。 

所以，把上面的

for

循环改成：

 
 for (int i = 0; i < n; i++)       
      
 cout << a[i] << " ";  //0 7 6 1 5 8 9       
     
         

让

i < n

就是只输出前面不重复的数字，这样就实现的去重的效果。

四、去重函数

unique

与排序函数

sort

结合

  如果先

去重

再

排序

那么结果就是：去重毫无作用。因为

去重

再

排序

排序时会把重复的数字又放在了一起，所以要先

排序

再

去重

。这点应该好理解，这里就提一下。

先

排序

再

去重

代码如下：

 
 #include <iostream>       
      
 #include <algorithm>  //sort(), unique()       
      
 #include <functional>  //less<int>()       
          
 using namespace std;       
          
 int main()       
      
 {       
      
 int i;       
      
 int a[10] = { 0, 7, 7, 6, 1, 1, 5, 5, 8, 9 };       
          
 sort( a, a + 10, less<int>() );  //排序       
          
 int n = unique(a, a + 10) - a;  //去重       
          
 for ( i = 0; i < n; i++)  //注意i < n       
      
 cout << a[i] << " ";  //0 1 5 6 7 8 9       
      
 }       
     
         

于是就得到了想要的结果：

先把数字排序，再

去掉重复数字。

五，以上便是去重应用于数组的情况：接下来看一下字符串的情况：

uniqe()函数是去掉重复的字符。是指两个字符连续出现就只留下一个，其余的就删除。例如:

 string s("hello,world");

 string::iterator iterEnd=unique(s.begin(),s.end());     //返回出现重复元素的迭代器位置

这代码执行后，s的值为helo,worldd. 只消除连续出现的同样的字符。重点是不连续的不消除。

unique函数通常和erase函数一起使用，来达到删除重复元素的目的。(注：此处的删除是真正的删除，即从容器中去除重复的元素，容器

的长度也发生了变换；而单纯的使用unique函数的话，容器的长度并没有发生变化，只是元素的位置发生了变化)

还有一个就是unqiue()函数删除重复的字符后，字符串长度不变，所以如果字符串删除字符后，后面按照之前的值填上。 所以就是helo,worldd，而不是helo,world；

所以就会有一个函数erase()函数存在的必要性了。它可以删除字符。

s.erase(iterEnd,s.end());      //删除掉重复元素；

执行后s的值就是我们想要的helo,world.

如果想要只留下一个字符l，只能先排序！！！！让他们挨在一块。

sort()函数是排序字符串字符。 即如果是akjsc,排序后为acjks.

所以一般用unique函数的时候都会用到erase(). sort()用到也也比较多。

六，总结：

 
 #include <iostream>       
      
 #include <algorithm>  //sort(), unique()       
      
 #include <functional>  //less<int>()       
      
 #include<string>       
      
 using namespace std;       
          
 int main()       
      
 {       
      
 /////////////////字符串的去重排序       
      
 string str = "sjscncmkzmxkz";       
          
 sort(str.begin(), str.end());        //先对字符串排序；       
          
 string::iterator itend = unique(str.begin(), str.end());  //返回出现重复元素的首地址；       
          
 cout << str << endl;       
          
 str.erase(itend, str.end());    //删除重复元素；       
          
 cout << str << endl;       
          
 ////////////数组的去重排序；       
      
 int a[10] = { 0, 7, 7, 6, 1, 1, 5, 5, 8, 9 };       
          
 sort(a, a + 10, less<int>());  //排序       
          
 int n = unique(a, a + 10) - a;        //去重       
      
 int n1 = distance(a, unique(a, a + n));   //获得不重复元素的个数；       
          
 for (int i = 0; i < n1; i++)  //注意i < n       
      
 cout << a[i] << " ";  //0 1 5 6 7 8 9       
      
 }