STL_算法_删除(unique、unique_copy)

C++ Primer 学习中。

。

。

简单记录下我的学习过程 (代码为主)

全部容器适用

unique(b,e)

unique(b,e,p)

unique_copy(b1,e1,b2)

unique_copy(b1,e1,b2,p)

注意：

    1、没有unique_if()

    2、没有unique_copy_if()

/**------http://blog.csdn.net/u010579068------**/
#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<list>
#include<deque>
#include<algorithm>
using namespace std;

/*****************************************
//全部容器适用
unique(b,e)
unique(b,e,p)
unique_copy(b1,e1,b2)
unique_copy(b1,e1,b2,p)
注意：
    1、没有unique_if()
    2、没有unique_copy_if()
*****************************************/
/**----------------------------------------------------------------------------------
使用方法：删除连续的、反复的元素
----------------------------------------------------------------------------------**/
/*************************************************************************************
std::unique                     全部排序容器适用                           algorithm
--------------------------------------------------------------------------------------
template <class ForwardIterator>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last );

template <class ForwardIterator, class BinaryPredicate>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last,
                           BinaryPredicate pred );
//eg：
template <class ForwardIterator>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last )
{
  ForwardIterator result=first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for the pred version
      *(++result)=*first;
  }
  return ++result;
}
*************************************************************************************/

/*************************************************************************************
std::unique_copy                   全部排序容器适用                        algorithm
--------------------------------------------------------------------------------------
template <class InputIterator, class OutputIterator>
  OutputIterator unique_copy ( InputIterator first, InputIterator last,
                               OutputIterator result );

template <class InputIterator, class OutputIterator, class BinaryPredicate>
  OutputIterator unique_copy ( InputIterator first, InputIterator last,
                               OutputIterator result, BinaryPredicate pred );
//eg：
template <class InputIterator, class OutputIterator>
  OutputIterator unique_copy ( InputIterator first, InputIterator last,
                               OutputIterator result )
{
  typename std::iterator_traits<InputIterator>::value_type value = *first;
  *result=*first;
  while (++first != last)
  {
    if (!(value == *first))  // or: if (!pred(value,*first)) for the pred version
      *(++result) = value = *first;
  }
  return ++result;
}
*************************************************************************************/

bool myfunction (int i, int j)
{
    return (i==j);
}
template<typename T>
void Print(T& V)
{
    typename T::iterator iter=V.begin();
    while(iter != V.end())
    {
        cout<<*iter++<<" ";
    }
    cout<<endl;
}
int main()
{
    int myints[] = {10,20,20,20,30,30,20,20,10};    // 10 20 20 20 30 30 20 20 10
    vector<int> myvector (myints,myints+9);
    vector<int>::iterator it,pend;

    // using default comparison:
    it = unique (myvector.begin(), myvector.end()); // 10 20 30 20 10 ?  ?

?

?
    //                ^

    myvector.resize( it - myvector.begin() );       // 10 20 30 20 10

    // using predicate comparison:
    unique (myvector.begin(), myvector.end(), myfunction);   // (no changes)

    // print out content:
    cout << "myvector contains:";
    for (it=myvector.begin(); it!=myvector.end(); ++it)
        cout << " " << *it;
    cout << endl;

    vector<int> vec;
    copy(myints,myints+9,back_inserter(vec));
    Print(vec);
    pend =unique(vec.begin(),vec.end(),greater<int>());//取单调不递减数列
    cout << "vec contains:";
    for (it=vec.begin(); it!=pend; ++it)
        cout << " " << *it;
    cout << endl << endl;
    /**--------------------------------------------------------------------------------**/

//    int myints[] = {10,20,20,20,30,30,20,20,10};
    deque<int> mydeque (9);                            // 0  0  0  0  0  0  0  0  0
    deque<int>::iterator id;

    // using default comparison:
    id=unique_copy (myints,myints+9,mydeque.begin());   // 10 20 30 20 10 0  0  0  0
    //                ^

    sort (mydeque.begin(),id);                          // 10 10 20 20 30 0  0  0  0
    //                ^

    // using predicate comparison:
    id=unique_copy (mydeque.begin(), id, mydeque.begin(), myfunction);
    // 10 20 30 20 30 0  0  0  0
    //          ^

    mydeque.resize( id - mydeque.begin() );            // 10 20 30

    // print out content:
    cout << "mydeque contains:";
    for (id=mydeque.begin(); id!=mydeque.end(); ++id)
        cout << " " << *id;

    cout << endl;

    return 0;
}