STL Mutating Algorithms小结

最新推荐文章于 2019-07-10 10:34:18 发布
最新推荐文章于 2019-07-10 10:34:18 发布
阅读量1k 收藏
点赞数 1
分类专栏： STL 文章标签： C++11 STL algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011000290/article/details/47837601
版权

与Non-mutating Algorithms相比，变易算法能修改容器元素数据，可进行序列数据的复制、交换、替换、填充、移除、旋转、随机抖动、分割。还是参考叶至军的那本书以及网站Cplusplus.com

copy

 

元素复制。该函数用于容器间元素拷贝，将迭代器区间[first, last)的元素复制到由复制目标迭代器result给定的区间[result, result + (last - first))。

template <class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);

Copies the elements in the range [first,last) into the range beginning at result.
The function returns an iterator to the end of the destination range (which points to the element following the last element copied).

template<class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = *first;
    ++result; ++first;
  }
  return result;
}

#include<iostream>
#include<algorithm>
#include<list>
#include<vector>
using namespace std;
void print(int x)
{
	cout<<x<<" ";
}
int main()
{
	vector<int> v;
	v.push_back(2);
    v.push_back(4);
    v.push_back(3);
    
    list<int> l(3);
    copy(v.begin(), v.end(), l.begin());
    for_each(l.begin(), l.end(), print);//2 4 3
	return 0;
}


 

copy_backward

反向复制。将一个迭代器区间的内容复制到另一迭代器区间，与copy()相似，不同的是复制过程从最后的元素开始。

template <class BidirectionalIterator1, class BidirectionalIterator2>
  BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,
                                        BidirectionalIterator1 last,
                                        BidirectionalIterator2 result);
Copies the elements in the range [first,last) starting from the end into the range terminating at result.
The function returns an iterator to the first element in the destination range.

template<class BidirectionalIterator1, class BidirectionalIterator2>
  BidirectionalIterator2 copy_backward ( BidirectionalIterator1 first,
                                         BidirectionalIterator1 last,
                                         BidirectionalIterator2 result )
{
  while (last!=first) *(--result) = *(--last);
  return result;
}

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{
	cout<<x<<" ";
}
int main()
{
	vector<int> v(4);
    for(int i=0;i<v.size();i++)
    {
    	v[i]=i+1;
    }
    vector<int> v2(8);
    copy_backward(v.begin(), v.end(), v2.end());
    for_each(v2.begin(), v2.end(), print);//0 0 0 0 1 2 3 4
	return 0;
}


swap

该函数的功能是实现两个元素的交换。虽然大多数容器内部都提供了swap函数，这里提供了更一般的迭代器形式。

C++98中，函数原型为：
template <class T> void swap (T& a, T& b);
C++11中，函数原型为：
template <class T> void swap (T& a, T& b)noexcept 
(is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value);
template <class T, size_t N> void swap(T (&a)[N], T (&b)[N])
  noexcept (noexcept(swap(*a,*b)));

template <class T> void swap (T& a, T& b)
{
  T c(std::move(a)); a=std::move(b); b=std::move(c);
}
template <class T, size_t N> void swap (T (&a)[N], T (&b)[N])
{
  for (size_t i = 0; i<N; ++i) swap (a[i],b[i]);
}
//交换a,b的值
#include <iostream>     // std::cout
#include <algorithm>    // std::swap
#include <vector>       // std::vector
int main () {
  int x=10, y=20;                              // x:10 y:20
  std::swap(x,y);                              // x:20 y:10

  std::vector<int> foo (4,x), bar (6,y);       // foo:4x20 bar:6x10
  std::swap(foo,bar);                          // foo:6x10 bar:4x20

  std::cout << "foo contains:";
  for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << ' ' << *it;
  return 0;
}

iter_swap

 迭代器交换。iter_swap函数是swap函数的迭代器形式，使交换算法更易用于一般的容器。

template <class ForwardIterator1, class ForwardIterator2>
  void iter_swap (ForwardIterator1 a, ForwardIterator2 b);
Swaps the elements pointed to by a and b.
The function calls swap (unqualified) to exchange the elements.

template <class ForwardIterator1, class ForwardIterator2>
  void iter_swap (ForwardIterator1 a, ForwardIterator2 b)
{
  swap (*a, *b);
}

#include <iostream>     // std::cout
#include <algorithm>    // std::iter_swap
#include <vector>       // std::vector
int main () {

  int myints[]={10,20,30,40,50 };              //   myints:  10  20  30  40  50
  std::vector<int> myvector (4,99);            // myvector:  99  99  99  99

  std::iter_swap(myints,myvector.begin());     //   myints: [99] 20  30  40  50
                                               // myvector: [10] 99  99  99

  std::iter_swap(myints+3,myvector.begin()+2); //   myints:  99  20  30 [99] 50
                                               // myvector:  10  99 [40] 99

  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;

  return 0;
}

swap_ranges

区间元素交换。

函数原型如下：

template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2)

Exchanges the values of each of the elements in the range [first1,last1) with those of their respective elements in the range beginning at first2.
The function calls swap (unqualified) to exchange the elements.

template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2)
{
  while (first1!=last1) {
    swap (*first1, *first2);
    ++first1; ++first2;
  }
  return first2;
}

#include <iostream>     // std::cout
#include <algorithm>    // std::swap_ranges
#include <vector>       // std::vector

int main () {
  std::vector<int> foo (5,10);        // foo: 10 10 10 10 10
  std::vector<int> bar (6,33);        // bar: 33 33 33 33 33 33

  std::swap_ranges(foo.begin()+1, foo.end()-1, bar.begin());

  // print out results of swap:
  std::cout << "foo contains:";
  for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << ' ' << *it;
  std::cout<<std::endl;

  std::cout << "bar contains:";
  for (std::vector<int>::iterator it=bar.begin(); it!=bar.end(); ++it)
    std::cout << ' ' << *it;
  std::cout <<std::endl;

  return 0;
}

transform

元素变换。该函数用于容器元素的变换操作。有两个使用原型，分别用于一元函数对象和二元函数操作。

template <class InputIterator, class OutputIterator, class UnaryOperation>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperation op)
 
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
  OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,
                            BinaryOperation binary_op)

Applies an operation sequentially to the elements of one (1) or two (2) ranges and stores the result in the range that begins at result.

template <class InputIterator, class OutputIterator, class UnaryOperator>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperator op)
{
  while (first1 != last1) {
    *result = op(*first1);  // or: *result=binary_op(*first1,*first2++);
    ++result; ++first1;
  }
  return result;
}

#include <iostream>     // std::cout
#include <algorithm>    // std::transform
#include <vector>       // std::vector
#include <functional>   // std::plus

int op_increase (int i) { return ++i; }

int main () {
  std::vector<int> foo;
  std::vector<int> bar;

  // set some values:
  for (int i=1; i<6; i++)
    foo.push_back (i*10);                         // foo: 10 20 30 40 50

  bar.resize(foo.size());                         // allocate space

  std::transform (foo.begin(), foo.end(), bar.begin(), op_increase);
                                                  // bar: 11 21 31 41 51

  // std::plus adds together its two arguments:
  std::transform (foo.begin(), foo.end(), bar.begin(), foo.begin(), std::plus<int>());
                                                  // foo: 21 41 61 81 101

  std::cout << "foo contains:";
  for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

replace

替换。

template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value)

template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value)
{
  while (first!=last) {
    if (*first == old_value) *first=new_value;
    ++first;
  }
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(3);
    v.push_back(5);
    v.push_back(8);
    v.push_back(5);
    replace(v.begin(), v.end(), 5, 6);
    for_each(v.begin(), v.end(), print);//3 6 8 6
    return 0;
}


 

replace_if

条件替换。该函数是replace函数的谓词判断版本，将满足谓词条件的元素替换为新值。

 

template <class ForwardIterator, class UnaryPredicate, class T>
  void replace_if (ForwardIterator first, ForwardIterator last,
                   UnaryPredicate pred, const T& new_value );


#include <iostream>     // std::cout
#include <algorithm>    // std::replace_if
#include <vector>       // std::vector

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  std::vector<int> myvector;

  // set some values:
  for (int i=1; i<10; i++) myvector.push_back(i);               // 1 2 3 4 5 6 7 8 9

  std::replace_if (myvector.begin(), myvector.end(), IsOdd, 0); // 0 2 0 4 0 6 0 8 0

  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

replace_copy

替换和复制。该函数先进行元素替换，再将元素复制到新容器。

template <class BidirectionalIterator, class OutputIterator>
  OutputIterator reverse_copy (BidirectionalIterator first,
                               BidirectionalIterator last, OutputIterator result);

//将容器v中值为5的元素的值替换为6，并复制到容器v2。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(3);
    v.push_back(5);
    v.push_back(8);
    vector<int> v2(v.size());
    replace_copy(v.begin(), v.end(), v2.begin(), 5, 6);
    for_each(v2.begin(), v2.end(), print);
    return 0;
}


 

replace_copy_if

条件替换和复制。该函数是replace_copy的一元谓词判断版本，用法相似。

template <class InputIterator, class OutputIterator, class UnaryPredicate, class T>
  OutputIterator replace_copy_if (InputIterator first, InputIterator last,
                                  OutputIterator result, UnaryPredicate pred,
                                  const T& new_value)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int odd(int x) {
    return !(x % 2);
}
int main(void) {
    vector<int> v;
    v.push_back(3);
    v.push_back(5);
    v.push_back(8);
    vector<int> v2(v.size());
    replace_copy_if(v.begin(), v.end(), v2.begin(), odd, 2);
    for_each(v2.begin(), v2.end(), print);
    return 0;
}

fill

填充。该函数将同一个值填充到迭代器区间内。

template <class ForwardIterator, class T>
  void fill (ForwardIterator first, ForwardIterator last, const T& val)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v(5);
    fill(v.begin(), v.end(), 9);
    for_each(v.begin(), v.end(), print);
    return 0;
}

fill_n

n次填充。与fill函数相似，但可指定填充的元素的个数。

template <class OutputIterator, class Size, class T>
  void fill_n (OutputIterator first, Size n, const T& val)

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{
	cout<<x<<" ";
}
int main()
{
	vector<int> v(4);
	for(int i=0;i<v.size();i++)
	v[i]=i+1;
	fill_n(v.begin()+1,2,10);
	for_each(v.begin(),v.end(),print);//1 10 10 4
	return 0;
}

generate

随机生成元素。该函数用于随机生成函数，将迭代器区间内的元素填充为生成的元素。


template <class ForwardIterator, class Generator>
  void generate (ForwardIterator first, ForwardIterator last, Generator gen)
//生成公比为3的等比数列
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int next(int x) {
    return 2;
}
class Seq {
public:
    int a;
    Seq() {
        a = 1;
    }
    inline int operator()() {
        a *= 3;
        return a;
    }
};
int main(void) {
    vector<int> v(5);
    Seq seq;
    generate(v.begin(), v.end(), seq);
    for_each(v.begin(), v.end(), print);
    return 0;
}

generate_n

随机生成n个元素。该函数与generate相似，只是限定了填入容器的数值个数。函数原型：

template <class OutputIterator, class Size, class Generator>
  void generate_n (OutputIterator first, Size n, Generator gen)

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void print(int x)
{
	cout<<x<<" ";
}

int main()
{
	vector<int> v(6);
	generate_n(v.begin(),3, rand);
	for_each(v.begin(),v.end(),print);
	return 0;
}

remove

移除。该函数用于将容器中等于某个给定值的元素全部移除掉，并返回表示容器结束位置的迭代器。函数原型：

template <class ForwardIterator, class T>
  ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)

template <class ForwardIterator, class T>
  ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
{
  ForwardIterator result = first;
  while (first!=last) {
    if (!(*first == val)) {
      *result = move(*first);
      ++result;
    }
    ++first;
  }
  return result;
}
//移除数组中的元素20
#include <iostream>     // std::cout
#include <algorithm>    // std::remove

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};      // 10 20 30 30 20 10 10 20

  // bounds of range:
  int* pbegin = myints;                          // ^
  int* pend = myints+sizeof(myints)/sizeof(int); // ^                       ^

  pend = std::remove (pbegin, pend, 20);         // 10 30 30 10 10 ?  ?  ?
                                                 // ^              ^
  std::cout << "range contains:";
  for (int* p=pbegin; p!=pend; ++p)
    std::cout << ' ' << *p;
  std::cout << '\n';

  return 0;
}

 

remove_if

条件移除。该函数是remove函数的一个带谓词判断的版本，将满足一元谓词判断条件的元素移除掉。

template <class ForwardIterator, class UnaryPredicate>
  ForwardIterator remove_if (ForwardIterator first, ForwardIterator last,
                             UnaryPredicate pred)
//将容器v中值为偶数的元素移除掉
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {
    return !(x % 2);
}
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(3);
    v.push_back(7);
    v.push_back(8);
    vector<int>::iterator result =  remove_if(v.begin(), v.end(), isOdd);
    for_each(v.begin(), result, print);
    return 0;
}

remove_copy

移除复制。该函数先进行元素移除，再将元素复制到新容器，实质上是一个条件复制。

 

template <class InputIterator, class OutputIterator, class T>
  OutputIterator remove_copy (InputIterator first, InputIterator last,
                              OutputIterator result, const T& val)
Copies the elements in the range [first,last) to the range beginning at result, except those elements that compare equal to val.
template <class InputIterator, class OutputIterator, class T>
  OutputIterator remove_copy (InputIterator first, InputIterator last,
                              OutputIterator result, const T& val)
{
  while (first!=last) {
    if (!(*first == val)) {
      *result = *first;
      ++result;
    }
    ++first;
  }
  return result;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {
    return !(x % 2);
}
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(3);
    v.push_back(7);
    v.push_back(8);
    vector<int>::iterator result =  remove_if(v.begin(), v.end(), isOdd);
    for_each(v.begin(), result, print);
    return 0;
}


remove_copy_if

条件移除复制。该函数是remove_copy的一个带谓词判断版本，将不满足一元谓词判断条件的元素复制到新容器。

 

template <class InputIterator, class OutputIterator, class UnaryPredicate>
  OutputIterator remove_copy_if (InputIterator first, InputIterator last,
                                 OutputIterator result, UnaryPredicate pred)


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {
    return !(x % 2);
}
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(3);
    v.push_back(7);
    v.push_back(8);
    vector<int> v2(5);
    remove_copy_if(v.begin(), v.end(), v2.begin(), isOdd);
    for_each(v2.begin(), v2.end(), print);
    return 0;
}


 unique

剔除连续重复元素。该函数用于剔除容器中连续重复的元素，只保留一个。有两个使用原型，可以使连续重复的原型，或不连续但满足二元谓词判断条件的元素。

template <class ForwardIterator>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last)
 
template <class ForwardIterator, class BinaryPredicate>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last,
                          BinaryPredicate pred)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(2);
    v.push_back(2);
    v.push_back(3);
    v.push_back(2);
    v.push_back(5);
    vector<int>::iterator result = unique(v.begin(), v.end());
    for_each(v.begin(), result, print);//2 3 2 5
    return 0;
}

 

unique_copy

不连续重复元素复制。该函数用于复制不连续重复的元素。同样有两个使用原型。

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)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(2);
    v.push_back(3);
    v.push_back(3);
    v.push_back(5);
    v.push_back(3);
    vector<int> v2(4);
    unique_copy(v.begin(), v.end(), v2.begin());
    for_each(v2.begin(), v2.end(), print);//2 3 5 3
    return 0;
}

reverse

元素反向。该函数用于容器元素的反向排列。

template <class BidirectionalIterator>
  void reverse (BidirectionalIterator first, BidirectionalIterator last)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(2);
    v.push_back(3);
    v.push_back(5);
    reverse(v.begin(), v.end());
    for_each(v.begin(), v.end(), print);
    return 0;
}

 

reverse_copy

反向复制。该函数用于反向复制容器元素。

template <class BidirectionalIterator, class OutputIterator>
  OutputIterator reverse_copy (BidirectionalIterator first,
                               BidirectionalIterator last, OutputIterator result)

//将容器v中的元素反向复制到新容器v2中
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    v.push_back(2);
    v.push_back(3);
    v.push_back(5);
    vector<int> v2(v.size());
    reverse_copy(v.begin(), v.end(), v2.begin());
    for_each(v2.begin(), v2.end(), print);
    return 0;
}

rotate

该函数用于旋转某个迭代器区间的元素。假设区间元素为{a0, a1, ..., ak, ..., an}，ak为middle位置，则旋转复制后，新区间元素为{ak, ak+1, ..., an, a0, a1, ..., ak-1}

函数原型：

 

template <class ForwardIterator>
  void rotate (ForwardIterator first, ForwardIterator middle,
               ForwardIterator last)

//将容器v以值为7的元素为支点旋转

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    for(int i = 0; i < 10; i++) {
        v.push_back(i + 1);
    }
    rotate(v.begin(), find(v.begin(), v.end(), 7), v.end());
    for_each(v.begin(), v.end(), print);
    return 0;
}

rotate_copy

旋转复制。该函数通过复制的方法实现旋转，比rotate函数更简单高效，但需要占用较多的内存空间。

template <class ForwardIterator, class OutputIterator>
  OutputIterator rotate_copy (ForwardIterator first, ForwardIterator middle,
                              ForwardIterator last, OutputIterator result)

//将以容器v中值为7的元素为支点旋转，将结果存储在容器v2中
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    for(int i = 0; i < 10; i++) {
        v.push_back(i + 1);
    }
    vector<int> v2(v.size());
    rotate_copy(v.begin(), find(v.begin(), v.end(), 7), v.end(), v2.begin());
    for_each(v2.begin(), v2.end(), print);
    return 0;
}

 

random_shuffle

随机抖动。该函数用于对容器元素进行随机的排列，有两个使用原型，使用C标准的伪随机函数rand或自定义的随机数发生器函数对象。

 

template <class RandomAccessIterator>
  void random_shuffle (RandomAccessIterator first, RandomAccessIterator last)
 
template <class RandomAccessIterator, class RandomNumberGenerator>
  void random_shuffle (RandomAccessIterator first, RandomAccessIterator last,
                       RandomNumberGenerator& gen)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int main(void) {
    vector<int> v;
    for(int i = 0; i < 10; i++) {
        v.push_back(i);
    }
    random_shuffle(v.begin(), v.end());
    for_each(v.begin(), v.end(), print);
    cout << endl;
    random_shuffle(v.begin(), v.end());
    for_each(v.begin(), v.end(), print);
    return 0;
}

random_sample

随机采样。SGI C++可能不支持。

 

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{
	cout<<x<<" ";
}
int main()
{
	vector<int> v(10);
	for(int i=0;i<v.size();i++)
	{
		v[i]=i%8;
	}
	 int n=6;
	int iArray[n];
	random_sample(v.begin(),v.end(),iArray,iArray+n);
	cout<<"采样元素为：";
	for_each(iArray,iArray+n,print);
	cout<<endl;
	return 0;
}

partition

容器分割。该函数用于重新分割排列容器的元素，按照医院谓词判断条件，分割成满足和不满足条件的两部分，返回的迭代器指向首个不满足条件的元素。

 

template <class BidirectionalIterator, class UnaryPredicate>
  BidirectionalIterator partition (BidirectionalIterator first,
                                   BidirectionalIterator last, UnaryPredicate pred)
//将容器v中的元素分为小于5和大于等于5的两部分，并分别将元素打印出来

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int less5(int x) {
    if(x < 5) {
        return 1;
    } else {
        return 0;
    }
}
int main(void) {
    vector<int> v;
    for(int i = 10; i > 0; i--) {
        v.push_back(i);
    }
    vector<int>::iterator iv = partition(v.begin(), v.end(), less5);
    cout << "less than 5: ";
    for_each(v.begin(), iv, print);
    cout << endl;
    cout << "no less than 5: ";
    for_each(iv, v.end(), print);
    return 0;
}

stable_partition

容器稳定分割。该函数与parition类似，重新分割排列容器的元素，但可以保持原有元素的先后顺序。

 

template <class BidirectionalIterator, class UnaryPredicate>
  BidirectionalIterator stable_partition (BidirectionalIterator first,
                                          BidirectionalIterator last,
                                          UnaryPredicate pred)

Rearranges the elements in the range [first,last), in such a way that all the elements for which pred returns true precede all those for which it returns false, and, unlike function partition, the relative order of elements within each group is preserved.
//将容器v中的元素分为小于5和大于等于5的两部分，但保持元素的稳定性
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
    cout << x << " ";
}
int less5(int x) {
    if(x < 5) {
        return 1;
    } else {
        return 0;
    }
}
int main(void) {
    vector<int> v;
    for(int i = 10; i > 0; i--) {
        v.push_back(i);
    }
    vector<int>::iterator iv = stable_partition(v.begin(), v.end(), less5);
    cout << "less than 5: ";
    for_each(v.begin(), iv, print);
    cout << endl;
    cout << "no less than 5: ";
    for_each(iv, v.end(), print);
    return 0;
}

 

CouchDB
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL 简单 <stl_algorithms.h> 算法的实现
chengonghao的博客
06-05 1416
1.简介 STL标准中，没有区分基本算法和复杂算法，然而SGI STL却把常用的算法定义在中。本文介绍部分算法的实现，给出实现代码和测试代码。          本文介绍的算法包括： 1.      mismatch：比较两个序列，指出两者之间第一个不匹配的点，返回一对迭代器，分别指向两序列中不匹配的点； 2.      equal：如果两个序列在 [first, last ] 区间内相等
变易算法（三）
hopegrace的博客
01-31 144
变易算法 C++STL的变易算法(Mutatingalgorithms)是一组能够修改容器元素数据的模板函数，可进行序列数据的复制，变换等。 25、随即抖动random_shuffle template<classRanIt> voidrandom_shuffle(RanItfirst,RanItlast); 将迭代器区间[first,last)上元素用C标准的...
STL Non-mutating Algorithms小结
面目全非，胸有丘壑 | Json Lee
08-21 1148
C++ STL中有许多非变易算法，这些算法不破坏操作数据，用来对序列数据进行逐个处理(for_each)、元素查找(find)、子序列搜索(find_first_of)、统计和匹配(count和mismatch)等。非变易算法在实现各种大型复杂一点的算法的时候比较方便，而且比较稳定，这也是STL本身固有的特点。主要列出以下几种，参考了叶志军的那本《C++ STL开发技术导引》，同时也结合网站C
泛型与STL Note2
sinat_17700695的博客
07-10 126
第三篇 参考手册:Algorithms and classes 十、Basic components 1.  pair(Class pair<T1，T2>是一个可拥有不同成分的数对，它有一个型别为T1的object以及一个型别为T2的object，访问第一个object用varName.first，第二个用varName.second；)； 2. &nbs...
C++ sgi STL学习笔记之non-mutating algorithm
Qer的博客
09-19 440
c++非变易算法
STL_algorithms1.md
07-29
STL的常用算法 常用遍历算法、常用查找算法、常用排序算法、常用拷贝和替换算法、常用算术生成算法、常用集合算法
Terse-STL-algorithms
05-12
简洁的STL算法 STL算法返回生成的容器。 例子 # include # include # include # include using namespace std ; using namespace terse ::dst_concrete ; using namespace terse ::dst_template ; using ...
STL学习小结
06-18
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它由容器、算法和迭代器三大部分组成。STL提供了一种高效、类型安全的方式来管理和操作数据，使得开发者能够更加专注于解决问题而...
stl学习小结, list用法
10-21
stl学习小结, 主要是以讲list为主
Your Brain: The Missing Manual
01-22
This is a book about that wet mass of cell tissue called the brain, and why it's responsible for everything from true love to getting you out of bed in the morning. One part science guide, one part self-help concierge, it's grounded in the latest neuroscience, psychology, and nutritional wisdom. The result? An essential guide for the modern brain owner, filled with ready-to-follow advice on everything from eating right to improving your memory.
STL（八）——算法(Algorithm)（一）
Pokemon_Master的博客
09-11 171
算法概观 STL算法是将最常被运用的算法规范出来，其涵盖的区间有可能在每五年一次的C++标准委员会中不断增订。广义而言，我们所写的每个程序都是一个算法，其中的每个函数也都是一个算法。STL收录了许多算法，包括排序，查找，排列组合等等的算法。STL为这些算法提供能泛化使用的版本。但要注意的是，特定的算法往往搭配特定的数据结构，例如RB-tree便是为了解决查找问题而提出的，本篇讨论的算法大多是独立...
【前端】bootstrap4实现导航栏（非nav）
diyinqian的博客
10-28 5738
效果展示： html代码： &amp;lt;!-- 右侧边栏 --&amp;gt; &amp;lt;div class=&quot;list-group&quot;&amp;gt; &amp;lt;button class=&quot;list-group-item all-type-div&quot;&amp;gt; &amp;lt;p class=&quot;list-group-item-h
STL 堆排序
面目全非，胸有丘壑 | Json Lee
08-22 7018
C++ STL中提供了不少和排序相关的算法，包括堆排序(heap_sort)、排序(sort)、稳定排序(stable_sort)、局部排序(partial_sort)，时间复杂度均为O(nlogn)。其中，对于堆排序，也提供了不少函数，像入堆push_heap、创建堆make_heap、出堆pop_heap，是否为堆is_heap等。首先要明确数据结构上堆的概念。对于一个迭代器区间上的元素，不管
map和multimap映射容器
面目全非，胸有丘壑 | Json Lee
08-18 5602
map容器 map所处理的数据与数据库表具有键值的记录很相似，在键值与映射数据之间，建立一个数学上的映射关系。map容器的数据结构仍然采用红黑树进行管理，插入的元素键值不允许重复，所使用的结点元素的比较函数只对元素的键值进行比较，元素的各项数据可以通过键值检索出来。对于键值和映射数据，可以通过pair封装成一个结构对象，map要做的就是将这个pair对象插入到红黑树中，同时也需要提供一个仅使用键
hash_set和hash_map
面目全非，胸有丘壑 | Json Lee
08-19 2284
1.hash_set集合容器 hash_set利用链式哈希表，进行数据的插入、删除和搜索。与set容器相同，不允许插入重复键值的元素。SGIC++哈希表是一个链式的结构，由表头和一系列单链组成。表头是一个数组式的线性表，用vector向量泛化出来。每个表头节点，称为桶(bucket)，是一个指针域，指向链入的元素数据。表头的长度为向量容器的元素个数。 哈希表中数据的遍历，迭代器从0号桶、1号桶
stack堆栈容器
面目全非，胸有丘壑 | Json Lee
08-19 1343
堆栈是一种线性表，插入和删除操作只在表的一端进行，该端成为栈顶，另一端则称为栈底。元素的入栈和出栈都是在栈顶进行的，因此堆栈是一种先进先出表。C++ STL的堆栈泛化是通过现有的序列容器来实现的，默认使用的是双端队列deque的数据结构。在STL中，stack的元素出栈操作是不返回栈顶元素的，获得栈顶元素需要调用相应的取栈顶函数才能获得，这种分离的实现，是考虑到出栈函数若是直接返回栈顶元素，将会导
priority_queue优先队列容器
面目全非，胸有丘壑 | Json Lee
08-19 1337
优先队列也是队列的一种，与一般队列的不同在于，队列中最大的元素总是位于队首的位置，每次元素的出队都是当前队列中最大的元素，底层的具体实现细节用到了堆(heap)。C++ STL中优先队列的泛化，底层默认采用vector向量容器，大概是考虑到队列容器的元素可以用做数组操作，就可以应用堆算法找出当前队列的最大元素，并将其调整到队首位置，确保最大元素优先出队。提供了获取队首的top函数，不提供获取队
stl stack大小
最新发布
09-02
STL中的stack是一种容器适配器，它基于deque（双端队列）实现，默认情况下。stack没有提供直接获取大小的成员函数，但是可以通过使用size函数来获取stack的大小。具体代码如下： ```cpp #include #include int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值