【C++STL】快速排序算法(sort)的原理与使用

这篇具有很好参考价值的文章主要介绍了【C++STL】快速排序算法(sort)的原理与使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、sort算法原理

std::sort 是 C++ 标准库中提供的排序算法,它使用的是一种经典的排序算法——快速排序(Quicksort)或者是其变种。

快速排序是一种基于比较的排序算法,通过不断地选择一个基准值(pivot),将待排序序列分割为两个子序列,其中一个子序列的所有元素小于等于基准值,另一个子序列的所有元素大于基准值。然后递归地对两个子序列进行排序,最终得到有序序列。

std::sort 在实现快速排序时,通常会结合其他优化技巧,如插入排序或堆排序,以提高算法的性能和效率。

快速排序的基本步骤:

  1. 选择一个基准值(pivot)。可以选择序列的第一个元素、最后一个元素、中间元素或者随机选择一个元素作为基准值。
  2. 将序列分割为两个子序列,使得一个子序列的所有元素小于等于基准值,另一个子序列的所有元素大于基准值。
  3. 递归地对两个子序列进行排序,即对小于等于基准值的子序列和大于基准值的子序列进行排序。
  4. 合并两个排序好的子序列,得到最终的有序序列。

快速排序是一种原地排序算法,它的平均时间复杂度为 O(nlogn),其中 n 是待排序序列的大小。在最坏情况下,快速排序的时间复杂度为 O(n^2),但通过合理选择基准值可以减少最坏情况的发生概率。

std::sort 的实现会考虑到不同情况下的性能和效率,并且在不同的编译器和库实现中可能有所不同。它通常会根据序列的大小、数据类型以及其他因素来选择合适的排序算法,以获得更好的性能。对于小型序列,std::sort 可能会使用插入排序或者其他简单的排序算法,而对于大型序列,它通常会采用快速排序或者其变种。此外,std::sort 还可以接受自定义的比较函数谓词,以满足不同的排序需求。

二、sort算法使用

功能: 对容器内元素进行排列(默认升序排列)

  • sort()属于质变算法
函数原型: sort(iterator beg, iterator end, pred) 解释
参数1 iterator beg 开始迭代器
参数2 iterator end 结束迭代器
参数3 pred 谓词

详细信息:

当调用 std::sort 进行排序时,它采用的是一种分治策略的快速排序算法,这意味着它将待排序的元素分割成较小的子集,然后对这些子集进行排序并逐步合并,最终得到完全排序的结果。

  • 排序范围:std::sort 排序的是一个范围,由两个迭代器 firstlast 指定,表示排序的起始位置和结束位置。排序将应用于 [first, last) 区间内的元素。
  • 排序准则: 默认情况下,std::sort 使用 < 运算符进行比较来确定元素的顺序。如果要按照其他准则进行排序,可以提供自定义的比较函数或函数对象作为可选的第三个参数。这个比较函数或函数对象应接受两个参数,并返回一个布尔值,指示第一个参数是否在排序中应排在第二个参数之前。
  • 时间复杂度:std::sort 使用快速排序算法,其平均时间复杂度为 O(n log n),其中 n 是要排序的元素的数量。在最坏情况下,快速排序的时间复杂度为 O(n^2),但这种情况很少发生。
  • 容器要求:std::sort 可以用于标准容器(如 std::vectorstd::dequestd::list 等)以及普通的数组。排序会就地进行,即直接修改容器中的元素顺序,而不会创建新的容器。
  • 可自定义类型:std::sort 不仅可以对基本类型(如整数、浮点数)进行排序,还可以对自定义类型进行排序,只要自定义类型支持比较操作符 < 或提供自定义的比较函数。
  • 迭代器失效:std::sort 不会使迭代器失效,这意味着在排序后仍然可以使用原始容器的迭代器。
  • 稳定性:std::sort 不保证排序的稳定性,即相等元素的顺序可能在排序后发生改变。如果需要保持相等元素的顺序不变,可以使用 std::stable_sort 算法。

示例1: 默认情况下为升序排列

#include <iostream>
#include <algorithm> //必须包含该头文件
#include <vector>
using namespace std;

//函数对象(仿函数)
class print
{
public:
	void operator()(int value)
	{
		cout << value << " ";
	}
};

void test01()
{
	vector<int> vec = {6, 9, 3, 4, 2, 7, 1, 5, 8};

	//排序前
	cout << "排序前:";
	for_each(vec.begin(), vec.end(), print());
	cout << endl;

	//排序后-升序
	cout << "排序后:";
	sort(vec.begin(), vec.end());   //默认升序
	for_each(vec.begin(), vec.end(), print());
	cout << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}
//result
排序前:6 9 3 4 2 7 1 5 8
排序后:1 2 3 4 5 6 7 8 9

示例2: 使用谓词std::greater<>

  • greater<> 是一个模板类,它是一个二元谓词(binary predicate),用于比较两个值的大小关系。
#include <iostream>
#include <algorithm> //必须包含该头文件
#include <vector>
using namespace std;

//函数对象(仿函数)
class print
{
public:
	void operator()(int value)
	{
		cout << value << " ";
	}
};

void test01()
{
	vector<int> vec = {6, 9, 3, 4, 2, 7, 1, 5, 8};

	//排序前
	cout << "排序前:";
	for_each(vec.begin(), vec.end(), print());
	cout << endl;

	//排序后-降序-添加谓词greater
	cout << "排序后:";
	sort(vec.begin(), vec.end(), greater<int>());
	for_each(vec.begin(), vec.end(), print());
	cout << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}
//result
排序前:6 9 3 4 2 7 1 5 8
排序后:9 8 7 6 5 4 3 2 1

示例3: 自定义类型排序

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

class goods
{
public:
    goods(string name, int price)
    {
        m_name = name;
        m_price = price;
    }

public:
    string m_name;
    int m_price;
};

// 自定义排序-根据商品价格升序
struct arrange
{
    bool operator()(const goods& value1, const goods& value2)
    {
        return value1.m_price < value2.m_price;
    }
};

class print
{
public:
    void operator()(const goods& value)
    {
        cout << "名称:" << value.m_name  << "\t价格:" << value.m_price << endl;
    }
};

void test01()
{
    goods goods1("可乐", 3);
    goods goods2("红牛", 5);
    goods goods3("脉动", 4);
    goods goods4("外星人", 6);
    goods goods5("雪碧", 3);
    goods goods6("哇哈哈", 2);

    vector<goods> vec;
    vec.push_back(goods1);
    vec.push_back(goods2);
    vec.push_back(goods3);
    vec.push_back(goods4);
    vec.push_back(goods5);
    vec.push_back(goods6);

    // 排序前
    cout << "排序前:" << endl;
    for_each(vec.begin(), vec.end(), print());
    cout << endl;

    // 排序后-升序-添加谓词arrange
    cout << "排序后:" << endl;
    sort(vec.begin(), vec.end(), arrange());
    for_each(vec.begin(), vec.end(), print());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}
//result
排序前:
名称:可乐      价格:3
名称:红牛      价格:5
名称:脉动      价格:4
名称:外星人    价格:6
名称:雪碧      价格:3
名称:哇哈哈    价格:2

排序后:
名称:哇哈哈    价格:2
名称:可乐      价格:3
名称:雪碧      价格:3
名称:脉动      价格:4
名称:红牛      价格:5
名称:外星人    价格:6

总结:std::sort 是一个高效、通用且灵活的排序算法。它在大多数情况下都能提供良好的性能,并且可以应用于不同类型的容器和自定义类型。然而,对于一些特殊需求,例如需要稳定排序或对大型容器进行排序,可能需要选择其他排序算法或使用自定义的排序实现。


如果这篇文章对你有所帮助,渴望获得你的一个点赞!

std::sort,C++,STL,排序算法,算法,c++文章来源地址https://www.toymoban.com/news/detail-699101.html

到了这里,关于【C++STL】快速排序算法(sort)的原理与使用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • python算法 之 快速排序(Quick Sort)

    时间复杂度 名称 示例算法 O(1) 常数时间复杂度 哈希表查找 O(logn) 对数时间复杂度 二分查找 O(n) 线性时间复杂度 遍历数组 O(nlogn) 线性对数时间复杂度 快速排序 O(n^2) 平方时间复杂度 冒泡排序、插入排序 O(n^3) 立方时间复杂度 矩阵乘法 O(2^n) 指数时间复杂度 穷举搜索 O(n!) 阶

    2024年02月04日
    浏览(39)
  • ⌈算法进阶⌋图论::拓扑排序(Topological Sorting)——快速理解到熟练运用

    目录  一、原理 1. 引例:207.课程表  2. 应用场景 3. 代码思路 二、代码模板 三、练习 1、210.课程表Ⅱ🟢 2、2392.给定条件下构造举证🟡 3、310.最小高度树🟡 4、 2603.收集树中金币 🔴 1. 引例:207.课程表 就如大学课程安排一样,如果要学习数据结构与算法、机器学习这类课程

    2024年02月11日
    浏览(43)
  • 【排序算法】深入理解快速排序算法:从原理到实现

    目录 1. 引言 2. 快速排序算法原理 3. 快速排序的时间复杂度分析 4. 快速排序的应用场景 5. 快速排序的优缺点分析 5.1 优点: 5.2 缺点: 6. Java、JavaScript 和 Python 实现快速排序算法 6.1 Java 实现: 6.2 JavaScript 实现: 6.3 Python 7. 总结        快速排序是一种经典的排序算法,它的

    2024年03月20日
    浏览(45)
  • 【C++】STL 算法 ⑤ ( 二元函数对象 | std::transform 算法简介 | 为 std::transform 算法传入一元函数对象进行转换操作 )

    \\\" 二元函数对象 \\\" 指的是 一个实例类 中 , 重载了 \\\" 函数调用操作符 () \\\" 函数 operator() , 并且该函数 接受 2 个参数 ; 如果 \\\" 重载 函数调用操作符 () 函数 \\\" 只接收一个参数 , 那么这个函数对象就是 一元函数对象 ; 下面的结构体类 函数对象 , 就是一个二元函数对象 , 其作用是将

    2024年01月18日
    浏览(60)
  • 快速排序算法详解(原理,时间复杂度,实现代码)

    快速排序算法详解(原理、实现和时间复杂度) 快速排序是对冒泡排序的一种改进,由 C.A.R.Hoare(Charles Antony Richard Hoare,东尼·霍尔)在 1962 年提出。 快速排序的基本思想是 :通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据比另一部分的所有数据

    2024年02月13日
    浏览(49)
  • 01_04_快速排序(Quick Sort)

    快速排序(Quick Sort)介绍: 是一种常用的排序算法,它采用分治的策略来对待排序的序列进行排序。快速排序的基本思想是选择一个基准元素,通过一趟排序将序列分割成两个子序列,其中一个子序列的所有元素都小于基准元素,另一个子序列的所有元素都大于基准元素。

    2024年02月10日
    浏览(34)
  • 排序算法(stable_sort(), sort())

    sort函数我相信大家都不陌生,今天介绍一个新的排序算法stable_sort stable_sort:稳定排序算法,维持相等元素的原有顺序。 假如我们定义一个字符串数组 这些字符串是按照字典序排列的,我们现在想要words按照单词长度从小到大重排的同时,还希望具有相同长度的元素按照字典

    2024年02月07日
    浏览(51)
  • 【排序算法】堆排序(Heap Sort)

    堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。 学习堆排序之前,有必要了解堆!若读者不熟悉堆,建议先了解堆(建议可以通过二叉堆,左倾堆,

    2024年02月01日
    浏览(68)
  • 46,排序算法sort

    排序算法sort 常用排序算法 sort 学习目标: 掌握i常用排序算法 算法简介: sort //对容器内元素进行排序 random_shuffle //洗牌,指定范围内的元素随机调整次序 merge //容器元素合并,并存储到另一容器中 reverse //反转指定范围的元素 功能描述: 对容器内元素进行排序 函数原型:

    2024年02月16日
    浏览(39)
  • 【算法】桶排序(Bucket Sort)详解

    桶排序(Bucket Sort)又称箱排序,是一种比较常用的排序算法。其算法原理是将数组分到有限数量的桶里,再对每个桶分别排好序(可以是递归使用桶排序,也可以是使用其他排序算法将每个桶分别排好序),最后一次将每个桶中排好序的数输出。 桶排序的思想就是把待排序

    2024年01月24日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包