STL中的排序算法详解

最新推荐文章于 2022-10-31 15:20:01 发布

zhu2695

最新推荐文章于 2022-10-31 15:20:01 发布

阅读量925

点赞数

分类专栏： C++ STL 文章标签：排序算法

本文链接：https://blog.csdn.net/zhu2695/article/details/8759817

版权

C++ STL 专栏收录该内容

29 篇文章 2 订阅

订阅专栏

1. 所有STL sort算法函数的名字列表:

函数名　　　　　　　　　功能描述

sort 　　　　　　　对给定区间所有元素进行排序

stable_sort 　　　　对给定区间所有元素进行稳定排序

partial_sort 　　　　对给定区间所有元素部分排序

partial_sort_copy 对给定区间复制并排序

nth_element 　　　找出给定区间的某个位置对应的元素

is_sorted 判断一个区间是否已经排好序

partition 　　　　使得符合某个条件的元素放在前面

stable_partition 相对稳定的使得符合某个条件的元素放在前面

2. 比较函数：

当你需要按照某种特定方式进行排序时，你需要给sort指定比较函数，否则程序会自动提供给你一个比较函数

vector < int > vect;

sort(vect.begin(), vect.end());//此时相当于调用

sort(vect.begin(), vect.end(), less<int>() );

sort 中的其他比较函数

equal_to 相等

not_equal_to 不相等

less 小于

greater 大于

less_equal 小于等于

greater_equal 大于等于

上述例子中系统自己为sort提供了less仿函数。在STL中还提供了其他仿函数，以下是仿函数列表: 不能直接写入仿函数的名字，而是要写其重载的()函数： less<int>();

当你的容器中元素时一些标准类型（int float char)或者string时，你可以直接使用这些函数模板。但如果你时自己定义的类型或者你需要按照其他方式排序，你可以有两种方法来达到效果：一种是自己写比较函数。另一种是重载类型的'<'操作赋。

3. 全排序：

全排序即把所给定范围所有的元素按照大小关系顺序排列。sort采用的是成熟的"快速排序算法"(目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法)。复杂度为n*log(n)。stable_sort采用的是"归并排序"，分派足够内存时，其算法复杂度为n*log(n), 否则其复杂度为n*log(n)*log(n)，其优点是会保持相等元素之间的相对位置在排序前后保持一致。

用于全排序的函数有：

1.void sort(RandomAccessIterator first, RandomAccessIterator last);

2.void sort(RandomAccessIterator first, RandomAccessIterator last,StrictWeakOrdering comp);

3.void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

4.void stable_sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp);

实例：

#include <vector>
#include <algorithm> // Include algorithms
#include <iostream>
#include <string>

using namespace std;

typedef struct
{
	string first;
	string last;
}NAME;

bool sortbyfirst(const NAME& n1, const NAME& n2)
{
	return (n1.first<n2.first);
}

bool sortbylast(const NAME& n1, const NAME& n2)
{
	return (n1.last<n2.last);
}

int main(int argc, char* argv[])
{
	vector<NAME> contacts;
	vector<NAME>::iterator j;

	NAME tmp;
	tmp.first = "liu";
	tmp.last = "bei";
	contacts.push_back(tmp);

	tmp.first = "zhao";
	tmp.last = "yun";
	contacts.push_back(tmp);

	tmp.first = "gun";
	tmp.last = "yu";
	contacts.push_back(tmp);

	tmp.first = "zhang";
	tmp.last = "fei";
	contacts.push_back(tmp);

	cout<<"by first:"<<endl; 

	sort(contacts.begin(), contacts.end(), sortbyfirst);

	for(j=contacts.begin(); j!= contacts.end(); j++)
	{
		cout<<j->first<<" "<<j->last<<endl;
	}

	cout<<endl<<"by last:"<<endl;

	sort(contacts.begin(), contacts.end(), sortbylast);

	for(j=contacts.begin(); j!= contacts.end(); j++)
	{
		cout<<j->first<<" "<<j->last<<endl;
	}
	return 0;
}

/*
输出：

by first:
gun yu
liu bei
zhang fei
zhao yun

by last:
liu bei
zhang fei
gun yu
zhao yun
*/

/* stable_sort: 功能和sort是一样的，唯一不同的是，元素间的原有相对位置在排序前后没有变化。
				(带有"stable"字样的排序，元素间的原有相对位置在排序前后没有变化。)

				stable_sort的用法与sort一致，区别是stable_sort函数遇到两个数相等时，不对其交换顺序；
				这个应用在数组里面不受影响，当函数参数传入的是结构体时，会发现两者之间的明显区别。

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

template <class RandomAccessIterator, class Compare>
  void stable_sort ( RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp );
*/

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

bool compare_as_ints (double i,double j)
{
  return (int(i)<int(j));
}

int main () {
  double mydoubles[] = {3.14, 1.41, 2.72, 4.67, 1.73, 1.32, 1.62, 2.58};

  std::vector<double> myvector;

  myvector.assign(mydoubles,mydoubles+8);

  std::cout << "using default comparison:";
  std::stable_sort (myvector.begin(), myvector.end());
  for (std::vector<double>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  myvector.assign(mydoubles,mydoubles+8);

  std::cout << "using 'compare_as_ints' :";
  std::stable_sort (myvector.begin(), myvector.end(), compare_as_ints);
  for (std::vector<double>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  system("pause");
  return 0;
}

/*
Output:

using default comparison: 1.32 1.41 1.62 1.73 2.58 2.72 3.14 4.67
using 'compare_as_ints' : 1.41 1.73 1.32 1.62 2.72 2.58 3.14 4.67
请按任意键继续. . .
*/

4. 局部排序：

partial_sort采用的堆排序（heapsort），它在任何情况下的复杂度都是n*log(n)。

局部排序其实是为了减少不必要的操作而提供的排序方式。

其函数原型为：

4.1 void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,RandomAccessIterator last);

4.2 void partial_sort(RandomAccessIterator first,RandomAccessIterator middle,RandomAccessIterator last, StrictWeakOrdering comp);

4.3 RandomAccessIterator partial_sort_copy(InputIterator first, InputIteratorlast,RandomAccessIteratorresult_first,RandomAccessIterator result_last);

4.4 RandomAccessIterator partial_sort_copy(InputIterator first, InputIteratorlast,RandomAccessIteratorresult_first,RandomAccessIterator result_last, Compare comp);

例如：班上有1000个学生，我想知道分数最低的5名是哪些人。

partial_sort(vect.begin(),vect.begin()+5,vect.end(),less<student>());

实例：

/*
template <class RandomAccessIterator>
  void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,
                     RandomAccessIterator last);
 
custom (2) template <class RandomAccessIterator, class Compare>
  void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,
                     RandomAccessIterator last, Compare comp); 

对迭代器first和last所指定范围中的元素进行偏序排序.经过排序的元素放到序列的前面部分,其余元素放到迭代器middle和last指定的范围内。

例如：
有一个赛跑成绩的集合，我们想知道前三名的成绩但并不关心其他名次的次序，可以这样对这个序列进行排序。
partial_sort（scores.begin(),scores.begin()+3,scores.end());
*/

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

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

bool myfunction (int i,int j) { return (i<j); }

int main () {
  int myints[] = {9,8,7,6,5,4,3,2,1};
  std::vector<int> myvector (myints, myints+9);

  // using default comparison (operator <):
  std::partial_sort (myvector.begin(), myvector.begin()+5, myvector.end());

  // using function as comp
  std::partial_sort (myvector.begin(), myvector.begin()+5, myvector.end(),myfunction);

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


  std::vector<int> myvector2(5);
  std::partial_sort_copy(myvector.begin(), myvector.begin()+5, myvector2.begin(), myvector2.end(), myfunction);
  // print out content:
  std::cout << "myvector2 contains:";
  for (std::vector<int>::iterator it=myvector2.begin(); it!=myvector2.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  system("pause");
  return 0;
}

/*
Output:

myvector contains: 1 2 3 4 5 9 8 7 6
myvector2 contains: 1 2 3 4 5
请按任意键继续. . .
*/

5. nth_element 指定元素排序

5.1 void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);

5.2 void nth_element(RandomAccessIterator first, RandomAccessIterator nth,RandomAccessIterator last,

StrictWeakOrdering comp);

例如：班上有1000个学生，我想知道分数排在倒数第4名的学生。

nth_element(vect.begin(), vect.begin()+3, vect.end(),less<student>());

实例：

/* nth_element: 作用为求第n小的元素，并把它放在第n位置上，下标是从0开始计数的，也就是说求第0小的元素就是最小的数。
				nth_element不会对整体进行排序。

   需要注意的是，此算法只对“随机访问迭代器”有效（如 vector），如果需要对 list 使用此算法，可先将 list 的所有元素
   拷贝至 vector（或者存储 list::iterator，对自定义类型效率更高），再使用此算法。
*/

/*
template <class RandomAccessIterator>
  void nth_element (RandomAccessIterator first, RandomAccessIterator nth,
                    RandomAccessIterator last);
 
custom (2) template <class RandomAccessIterator, class Compare>
  void nth_element (RandomAccessIterator first, RandomAccessIterator nth,
                    RandomAccessIterator last, Compare comp); 
*/

#include <iostream>     // std::cout
#include <algorithm>    // std::nth_element, std::random_shuffle
#include <vector>       // std::vector

bool myfunction (int i,int j) { return (i<j); }

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::random_shuffle (myvector.begin(), myvector.end());

  // using default comparison (operator <):
  std::nth_element (myvector.begin(), myvector.begin()+5, myvector.end());

  // using function as comp
  std::nth_element (myvector.begin(), myvector.begin()+5, myvector.end(),myfunction);

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

  system("pause");
  return 0;
}

/*
Output:

myvector contains: 1 2 3 4 5 6 7 8 9
请按任意键继续. . .
*/

6. partition 和stable_partition

partition就是把一个区间中的元素按照某个条件分成两类，并没有排序。

其函数原型为：

6.1 ForwardIterator partition(ForwardIterator first, ForwardIterator last, Predicate pred)

6.2 ForwardIterator stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);

例如：班上10个学生，计算所有没有及格（低于60分）的学生：

student exam("pass", 60);

stable_partition(vect.begin(), vect.end(), bind2nd(less<student>(), exam));

实例：

/* partition: 将序列按指定条件来划分成2部分(第一部分是符合条件的所有元素)，返回第二部分的第一个元素的位置。
			  注意，序列被划分成2部分后，各个元素的相对位置往往已被打乱。

template <class ForwardIterator, class UnaryPredicate>
  ForwardIterator partition (ForwardIterator first,
                             ForwardIterator last, UnaryPredicate pred);
*/

#include <iostream>     // std::cout
#include <algorithm>    // std::partition
#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::vector<int>::iterator bound;
  bound = std::partition (myvector.begin(), myvector.end(), IsOdd);

  // print out content:
  std::cout << "odd elements:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=bound; ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

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

  system("pause");
  return 0;
}

/*
Output:

odd elements: 1 9 3 7 5
even elements: 6 4 8 2
请按任意键继续. . .
*/

/* stable_partition: 功能和partition是一样的，唯一不同的是，序列被划分成2部分后，各个元素原有的相对位置没有变化。
					 (带有"stable"字样的排序，元素间的原有相对位置在排序前后没有变化。)

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

#include <iostream>     // std::cout
#include <algorithm>    // std::stable_partition
#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::vector<int>::iterator bound;
  bound = std::stable_partition (myvector.begin(), myvector.end(), IsOdd);

  // print out content:
  std::cout << "odd elements:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=bound; ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

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

  system("pause");
  return 0;
}

/*
Output:

odd elements: 1 3 5 7 9
even elements: 2 4 6 8
请按任意键继续. . .
*/

7. 效率由高到低：

partion

stable_partition

nth_element

partial_sort

sort

stable_sort

8.如何选择恰当的排序算法：

8.1 若需对vector, string, deque, 或array容器进行全排序，你可选择sort或stable_sort；

8.2 若只需对vector, string, deque, 或array容器中取得top n的元素，部分排序partial_sort是首选.

8.3 若对于vector, string, deque, 或array容器，你需要找到第n个位置的元素或者你需要得到top n且不关系top n中的内部顺序，nth_element是最理想的；

8.4 若你需要从标准序列容器或者array中把满足某个条件或者不满足某个条件的元素分开，你最好使用partition或stable_partition；

8.5 若使用的list容器，你可以直接使用partition和stable_partition算法，你可以使用list::sort代替sort和stable_sort排序。

zhu2695

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
STL中的排序算法详解

1. 所有STL sort算法函数的名字列表:函数名　　　　　　　　　功能描述sort 　　　　　　　对给定区间所有元素进行排序stable_sort 　　　　对给定区间所有元素进行稳定排序partial_sort 　　　　对给定区间所有元素部分排序partial_sort_copy 对给定区间复制并排序nth_element 　　　找出给定区间的某个位
复制链接

扫一扫

专栏目录