STL 中排序和通用的算法（ 14 个）

最新推荐文章于 2022-03-14 18:45:54 发布

DevHui

最新推荐文章于 2022-03-14 18:45:54 发布

阅读量215

点赞数

文章标签：算法 class merge random iterator

本文链接：https://blog.csdn.net/psh2012/article/details/7592422

版权

1. inplace_merge： 合并两个有序序列， 结果序列覆盖两端范围

template <class BidirectionalIterator>
  void inplace_merge ( BidirectionalIterator first, BidirectionalIterator middle,
                       BidirectionalIterator last );

eg:	int Array1[] = { 20, 10, 30, 50, 40 };

	int Array2[] = { 11, 31, 21, 51, 41 };

	vector<int> ivec(10);

	sort( Array1, Array1 + sizeof(Array1) );

	sort( Array2, Array2 + sizeof(Array2) );

	copy( Array1, Array1 + sizeof(Array1), ivec.begin() );

	copy( Array2, Array2 + sizeof(Array2), ivec.begin() + sizeof(Array1) );

	inplace_merge( ivec.begin(), ivec.begin() + sizeof(Array1), ivec.end() );

2. merge: 合并两个有序序列，存放到另一个序列中。

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge ( InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result )
{
  while (true) {
    *result++ = (*first2<*first1)? *first2++ : *first1++;
    if (first1==last1) return copy(first2,last2,result);
    if (first2==last2) return copy(first1,last1,result);
  }
}

eg:
		sort( Array1, Array1 + sizeof(Array1) );
	sort( Array2, Array2 + sizeof(Array2) );
	merge( Array1, Array1 + sizeof(Array1), Array2,
		Array2 + sizeof(Array2), ivec.begin() );

3. random_shuffle : 对指定范围内的元素随机调整次序。

template <class RandomAccessIterator, class RandomNumberGenerator>
  void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last,
                        RandomNumberGenerator& rand )
{
  iterator_traits<RandomAccessIterator>::difference_type i, n;
  n = (last-first);
  for (i=n-1; i>0; --i) swap (first[i],first[rand(i+1)]);
}


4. nth_element： 将范围内的序列重新排序，小于第n个的元素放在他的前面，而大于它的都出现在后面。

template <class RandomAccessIterator>
  void nth_element ( RandomAccessIterator first, RandomAccessIterator nth,
                     RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void nth_element ( RandomAccessIterator first, RandomAccessIterator nth,
                     RandomAccessIterator last, Compare comp );
eg:
	nth_element（ ivec.begin(), ivec.begin() + 3, ivec.end() );
5. partial_sort : 对序列进行部分排序， 被排序的元素个数正好可以被放到范围内。 
6. partial_sort_copy: 排序后将结果放在另一个容器中，拷贝的元素个数，由另一个容器的Size决定
template <class RandomAccessIterator>
  void partial_sort ( RandomAccessIterator first, RandomAccessIterator middle,
                      RandomAccessIterator last );

template <class RandomAccessIterator, class Compare>
  void partial_sort ( RandomAccessIterator first, RandomAccessIterator middle,
                      RandomAccessIterator last, Compare comp );
template <class InputIterator, class RandomAccessIterator>
  RandomAccessIterator
    partial_sort_copy ( InputIterator first,InputIterator last,
                        RandomAccessIterator result_first,
                        RandomAccessIterator result_last );

template <class InputIterator, class RandomAccessIterator, class Compare>
  RandomAccessIterator
    partial_sort_copy ( InputIterator first,InputIterator last,
                        RandomAccessIterator result_first,
                        RandomAccessIterator result_last, Compare comp );


eg:
	partial_sort( ivec.begin(), ivec.begin() + 6, ivec.end() );
	
7. partition: 对指定范围内的元素重新排序，使用输入的函数，把结果为true的元素放在结果为false的元素之前。
template <class BidirectionalIterator, class Predicate>
  BidirectionalIterator partition ( BidirectionalIterator first,
                                    BidirectionalIterator last, Predicate pred )
{
  while (true)
  {
    while (first!=last && pred(*first)) ++first;
    if (first==last--) break;
    while (first!=last && !pred(*last)) --last;
    if (first==last) break;
    swap (*first++,*last);
  }
  return first;
}

eg:
	partition( ivec.begin(), ivec.end(), fun );

8. reverse: 将指定范围内元素重新反序排序。
9. reverse_copy ：与reverse类似，不过将结果写入另一个容器。原容器中的元素顺序不变

template <class BidirectionalIterator>
  void reverse ( BidirectionalIterator first, BidirectionalIterator last)
{
  while ((first!=last)&&(first!=--last))
    swap (*first++,*last);
}

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

10. rotate ： 将指定范围内的元素移到容器末尾， 由middle指向的元素成为容器的第一个元素。
11. rotate_copy: 将rotate后的元素输出到新的容器中。

template <class ForwardIterator>
  void rotate ( ForwardIterator first, ForwardIterator middle,
                ForwardIterator last )
{
  ForwardIterator next = middle;
  while (first!=next)
  {
    swap (*first++,*next++);
    if (next==last) next=middle;
    else if (first == middle) middle=next;
  }
}

template <class ForwardIterator, class OutputIterator>
  OutputIterator rotate_copy ( ForwardIterator first, ForwardIterator middle,
                               ForwardIterator last, OutputIterator result )
{
  result=copy (middle,last,result);
  return copy (first,middle,result);
}

12. sort ： 升序排序
13. stable_sort ：同sort，但保留相等元素之间的顺序关系
14. stable_partition ：同partition 不保留容器中的相对位置。
template <class BidirectionalIterator, class Predicate>
  BidirectionalIterator stable_partition ( BidirectionalIterator first,
                                           BidirectionalIterator last,
                                           Predicate pred );